var $protobuf = window.protobuf;
$protobuf.roots.default=window;
// Common aliases
var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;

// Exported root namespace
var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});

$root.awesomepackage = (function() {

    /**
     * Namespace awesomepackage.
     * @exports awesomepackage
     * @namespace
     */
    var awesomepackage = {};

    awesomepackage.AwesomeMessage = (function() {

        /**
         * Properties of an AwesomeMessage.
         * @memberof awesomepackage
         * @interface IAwesomeMessage
         * @property {number} meesageId AwesomeMessage meesageId
         * @property {Uint8Array|null} [data] AwesomeMessage data
         */

        /**
         * Constructs a new AwesomeMessage.
         * @memberof awesomepackage
         * @classdesc Represents an AwesomeMessage.
         * @implements IAwesomeMessage
         * @constructor
         * @param {awesomepackage.IAwesomeMessage=} [properties] Properties to set
         */
        function AwesomeMessage(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * AwesomeMessage meesageId.
         * @member {number} meesageId
         * @memberof awesomepackage.AwesomeMessage
         * @instance
         */
        AwesomeMessage.prototype.meesageId = 0;

        /**
         * AwesomeMessage data.
         * @member {Uint8Array} data
         * @memberof awesomepackage.AwesomeMessage
         * @instance
         */
        AwesomeMessage.prototype.data = $util.newBuffer([]);

        /**
         * Creates a new AwesomeMessage instance using the specified properties.
         * @function create
         * @memberof awesomepackage.AwesomeMessage
         * @static
         * @param {awesomepackage.IAwesomeMessage=} [properties] Properties to set
         * @returns {awesomepackage.AwesomeMessage} AwesomeMessage instance
         */
        AwesomeMessage.create = function create(properties) {
            return new AwesomeMessage(properties);
        };

        /**
         * Encodes the specified AwesomeMessage message. Does not implicitly {@link awesomepackage.AwesomeMessage.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.AwesomeMessage
         * @static
         * @param {awesomepackage.IAwesomeMessage} message AwesomeMessage message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        AwesomeMessage.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.meesageId);
            if (message.data != null && message.hasOwnProperty("data"))
                writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.data);
            return writer;
        };

        /**
         * Encodes the specified AwesomeMessage message, length delimited. Does not implicitly {@link awesomepackage.AwesomeMessage.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.AwesomeMessage
         * @static
         * @param {awesomepackage.IAwesomeMessage} message AwesomeMessage message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        AwesomeMessage.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an AwesomeMessage message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.AwesomeMessage
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.AwesomeMessage} AwesomeMessage
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        AwesomeMessage.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.AwesomeMessage();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.meesageId = reader.int32();
                    break;
                case 2:
                    message.data = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("meesageId"))
                throw $util.ProtocolError("missing required 'meesageId'", { instance: message });
            return message;
        };

        /**
         * Decodes an AwesomeMessage message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.AwesomeMessage
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.AwesomeMessage} AwesomeMessage
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        AwesomeMessage.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an AwesomeMessage message.
         * @function verify
         * @memberof awesomepackage.AwesomeMessage
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        AwesomeMessage.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.meesageId))
                return "meesageId: integer expected";
            if (message.data != null && message.hasOwnProperty("data"))
                if (!(message.data && typeof message.data.length === "number" || $util.isString(message.data)))
                    return "data: buffer expected";
            return null;
        };

        return AwesomeMessage;
    })();

    awesomepackage.c2sLogin = (function() {

        /**
         * Properties of a c2sLogin.
         * @memberof awesomepackage
         * @interface Ic2sLogin
         * @property {number} account c2sLogin account
         * @property {string} sign c2sLogin sign
         * @property {string} deessUp c2sLogin deessUp
         * @property {string} nickname c2sLogin nickname
         * @property {string} headUrl c2sLogin headUrl
         * @property {boolean} sex c2sLogin sex
         */

        /**
         * Constructs a new c2sLogin.
         * @memberof awesomepackage
         * @classdesc Represents a c2sLogin.
         * @implements Ic2sLogin
         * @constructor
         * @param {awesomepackage.Ic2sLogin=} [properties] Properties to set
         */
        function c2sLogin(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sLogin account.
         * @member {number} account
         * @memberof awesomepackage.c2sLogin
         * @instance
         */
        c2sLogin.prototype.account = 0;

        /**
         * c2sLogin sign.
         * @member {string} sign
         * @memberof awesomepackage.c2sLogin
         * @instance
         */
        c2sLogin.prototype.sign = "";

        /**
         * c2sLogin deessUp.
         * @member {string} deessUp
         * @memberof awesomepackage.c2sLogin
         * @instance
         */
        c2sLogin.prototype.deessUp = "";

        /**
         * c2sLogin nickname.
         * @member {string} nickname
         * @memberof awesomepackage.c2sLogin
         * @instance
         */
        c2sLogin.prototype.nickname = "";

        /**
         * c2sLogin headUrl.
         * @member {string} headUrl
         * @memberof awesomepackage.c2sLogin
         * @instance
         */
        c2sLogin.prototype.headUrl = "";

        /**
         * c2sLogin sex.
         * @member {boolean} sex
         * @memberof awesomepackage.c2sLogin
         * @instance
         */
        c2sLogin.prototype.sex = false;

        /**
         * Creates a new c2sLogin instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sLogin
         * @static
         * @param {awesomepackage.Ic2sLogin=} [properties] Properties to set
         * @returns {awesomepackage.c2sLogin} c2sLogin instance
         */
        c2sLogin.create = function create(properties) {
            return new c2sLogin(properties);
        };

        /**
         * Encodes the specified c2sLogin message. Does not implicitly {@link awesomepackage.c2sLogin.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sLogin
         * @static
         * @param {awesomepackage.Ic2sLogin} message c2sLogin message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sLogin.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.sign);
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.deessUp);
            writer.uint32(/* id 4, wireType 2 =*/34).string(message.nickname);
            writer.uint32(/* id 5, wireType 2 =*/42).string(message.headUrl);
            writer.uint32(/* id 6, wireType 0 =*/48).bool(message.sex);
            return writer;
        };

        /**
         * Encodes the specified c2sLogin message, length delimited. Does not implicitly {@link awesomepackage.c2sLogin.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sLogin
         * @static
         * @param {awesomepackage.Ic2sLogin} message c2sLogin message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sLogin.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sLogin message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sLogin
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sLogin} c2sLogin
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sLogin.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sLogin();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.sign = reader.string();
                    break;
                case 3:
                    message.deessUp = reader.string();
                    break;
                case 4:
                    message.nickname = reader.string();
                    break;
                case 5:
                    message.headUrl = reader.string();
                    break;
                case 6:
                    message.sex = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("sign"))
                throw $util.ProtocolError("missing required 'sign'", { instance: message });
            if (!message.hasOwnProperty("deessUp"))
                throw $util.ProtocolError("missing required 'deessUp'", { instance: message });
            if (!message.hasOwnProperty("nickname"))
                throw $util.ProtocolError("missing required 'nickname'", { instance: message });
            if (!message.hasOwnProperty("headUrl"))
                throw $util.ProtocolError("missing required 'headUrl'", { instance: message });
            if (!message.hasOwnProperty("sex"))
                throw $util.ProtocolError("missing required 'sex'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sLogin message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sLogin
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sLogin} c2sLogin
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sLogin.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sLogin message.
         * @function verify
         * @memberof awesomepackage.c2sLogin
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sLogin.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isString(message.sign))
                return "sign: string expected";
            if (!$util.isString(message.deessUp))
                return "deessUp: string expected";
            if (!$util.isString(message.nickname))
                return "nickname: string expected";
            if (!$util.isString(message.headUrl))
                return "headUrl: string expected";
            if (typeof message.sex !== "boolean")
                return "sex: boolean expected";
            return null;
        };

        return c2sLogin;
    })();

    awesomepackage.s2cErroMessage = (function() {

        /**
         * Properties of a s2cErroMessage.
         * @memberof awesomepackage
         * @interface Is2cErroMessage
         * @property {number} errorId s2cErroMessage errorId
         * @property {string} errorMessage s2cErroMessage errorMessage
         */

        /**
         * Constructs a new s2cErroMessage.
         * @memberof awesomepackage
         * @classdesc Represents a s2cErroMessage.
         * @implements Is2cErroMessage
         * @constructor
         * @param {awesomepackage.Is2cErroMessage=} [properties] Properties to set
         */
        function s2cErroMessage(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cErroMessage errorId.
         * @member {number} errorId
         * @memberof awesomepackage.s2cErroMessage
         * @instance
         */
        s2cErroMessage.prototype.errorId = 0;

        /**
         * s2cErroMessage errorMessage.
         * @member {string} errorMessage
         * @memberof awesomepackage.s2cErroMessage
         * @instance
         */
        s2cErroMessage.prototype.errorMessage = "";

        /**
         * Creates a new s2cErroMessage instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cErroMessage
         * @static
         * @param {awesomepackage.Is2cErroMessage=} [properties] Properties to set
         * @returns {awesomepackage.s2cErroMessage} s2cErroMessage instance
         */
        s2cErroMessage.create = function create(properties) {
            return new s2cErroMessage(properties);
        };

        /**
         * Encodes the specified s2cErroMessage message. Does not implicitly {@link awesomepackage.s2cErroMessage.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cErroMessage
         * @static
         * @param {awesomepackage.Is2cErroMessage} message s2cErroMessage message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cErroMessage.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorId);
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
            return writer;
        };

        /**
         * Encodes the specified s2cErroMessage message, length delimited. Does not implicitly {@link awesomepackage.s2cErroMessage.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cErroMessage
         * @static
         * @param {awesomepackage.Is2cErroMessage} message s2cErroMessage message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cErroMessage.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cErroMessage message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cErroMessage
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cErroMessage} s2cErroMessage
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cErroMessage.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cErroMessage();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.errorId = reader.int32();
                    break;
                case 2:
                    message.errorMessage = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("errorId"))
                throw $util.ProtocolError("missing required 'errorId'", { instance: message });
            if (!message.hasOwnProperty("errorMessage"))
                throw $util.ProtocolError("missing required 'errorMessage'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cErroMessage message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cErroMessage
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cErroMessage} s2cErroMessage
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cErroMessage.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cErroMessage message.
         * @function verify
         * @memberof awesomepackage.s2cErroMessage
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cErroMessage.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.errorId))
                return "errorId: integer expected";
            if (!$util.isString(message.errorMessage))
                return "errorMessage: string expected";
            return null;
        };

        return s2cErroMessage;
    })();

    awesomepackage.c2sEnterRoom = (function() {

        /**
         * Properties of a c2sEnterRoom.
         * @memberof awesomepackage
         * @interface Ic2sEnterRoom
         * @property {number} account c2sEnterRoom account
         * @property {number|null} [waitRoomId] c2sEnterRoom waitRoomId
         */

        /**
         * Constructs a new c2sEnterRoom.
         * @memberof awesomepackage
         * @classdesc Represents a c2sEnterRoom.
         * @implements Ic2sEnterRoom
         * @constructor
         * @param {awesomepackage.Ic2sEnterRoom=} [properties] Properties to set
         */
        function c2sEnterRoom(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sEnterRoom account.
         * @member {number} account
         * @memberof awesomepackage.c2sEnterRoom
         * @instance
         */
        c2sEnterRoom.prototype.account = 0;

        /**
         * c2sEnterRoom waitRoomId.
         * @member {number} waitRoomId
         * @memberof awesomepackage.c2sEnterRoom
         * @instance
         */
        c2sEnterRoom.prototype.waitRoomId = 0;

        /**
         * Creates a new c2sEnterRoom instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sEnterRoom
         * @static
         * @param {awesomepackage.Ic2sEnterRoom=} [properties] Properties to set
         * @returns {awesomepackage.c2sEnterRoom} c2sEnterRoom instance
         */
        c2sEnterRoom.create = function create(properties) {
            return new c2sEnterRoom(properties);
        };

        /**
         * Encodes the specified c2sEnterRoom message. Does not implicitly {@link awesomepackage.c2sEnterRoom.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sEnterRoom
         * @static
         * @param {awesomepackage.Ic2sEnterRoom} message c2sEnterRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sEnterRoom.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            if (message.waitRoomId != null && message.hasOwnProperty("waitRoomId"))
                writer.uint32(/* id 2, wireType 0 =*/16).int32(message.waitRoomId);
            return writer;
        };

        /**
         * Encodes the specified c2sEnterRoom message, length delimited. Does not implicitly {@link awesomepackage.c2sEnterRoom.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sEnterRoom
         * @static
         * @param {awesomepackage.Ic2sEnterRoom} message c2sEnterRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sEnterRoom.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sEnterRoom message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sEnterRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sEnterRoom} c2sEnterRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sEnterRoom.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sEnterRoom();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.waitRoomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sEnterRoom message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sEnterRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sEnterRoom} c2sEnterRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sEnterRoom.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sEnterRoom message.
         * @function verify
         * @memberof awesomepackage.c2sEnterRoom
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sEnterRoom.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (message.waitRoomId != null && message.hasOwnProperty("waitRoomId"))
                if (!$util.isInteger(message.waitRoomId))
                    return "waitRoomId: integer expected";
            return null;
        };

        return c2sEnterRoom;
    })();

    awesomepackage.s2cEnterRoom = (function() {

        /**
         * Properties of a s2cEnterRoom.
         * @memberof awesomepackage
         * @interface Is2cEnterRoom
         * @property {number} gameWidth s2cEnterRoom gameWidth
         * @property {number} gameHeight s2cEnterRoom gameHeight
         * @property {number} roomId s2cEnterRoom roomId
         * @property {number} roomTime s2cEnterRoom roomTime
         * @property {number|Long} roomStartTime s2cEnterRoom roomStartTime
         */

        /**
         * Constructs a new s2cEnterRoom.
         * @memberof awesomepackage
         * @classdesc Represents a s2cEnterRoom.
         * @implements Is2cEnterRoom
         * @constructor
         * @param {awesomepackage.Is2cEnterRoom=} [properties] Properties to set
         */
        function s2cEnterRoom(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cEnterRoom gameWidth.
         * @member {number} gameWidth
         * @memberof awesomepackage.s2cEnterRoom
         * @instance
         */
        s2cEnterRoom.prototype.gameWidth = 0;

        /**
         * s2cEnterRoom gameHeight.
         * @member {number} gameHeight
         * @memberof awesomepackage.s2cEnterRoom
         * @instance
         */
        s2cEnterRoom.prototype.gameHeight = 0;

        /**
         * s2cEnterRoom roomId.
         * @member {number} roomId
         * @memberof awesomepackage.s2cEnterRoom
         * @instance
         */
        s2cEnterRoom.prototype.roomId = 0;

        /**
         * s2cEnterRoom roomTime.
         * @member {number} roomTime
         * @memberof awesomepackage.s2cEnterRoom
         * @instance
         */
        s2cEnterRoom.prototype.roomTime = 0;

        /**
         * s2cEnterRoom roomStartTime.
         * @member {number|Long} roomStartTime
         * @memberof awesomepackage.s2cEnterRoom
         * @instance
         */
        s2cEnterRoom.prototype.roomStartTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

        /**
         * Creates a new s2cEnterRoom instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cEnterRoom
         * @static
         * @param {awesomepackage.Is2cEnterRoom=} [properties] Properties to set
         * @returns {awesomepackage.s2cEnterRoom} s2cEnterRoom instance
         */
        s2cEnterRoom.create = function create(properties) {
            return new s2cEnterRoom(properties);
        };

        /**
         * Encodes the specified s2cEnterRoom message. Does not implicitly {@link awesomepackage.s2cEnterRoom.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cEnterRoom
         * @static
         * @param {awesomepackage.Is2cEnterRoom} message s2cEnterRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cEnterRoom.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.gameWidth);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.gameHeight);
            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.roomId);
            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.roomTime);
            writer.uint32(/* id 5, wireType 0 =*/40).int64(message.roomStartTime);
            return writer;
        };

        /**
         * Encodes the specified s2cEnterRoom message, length delimited. Does not implicitly {@link awesomepackage.s2cEnterRoom.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cEnterRoom
         * @static
         * @param {awesomepackage.Is2cEnterRoom} message s2cEnterRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cEnterRoom.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cEnterRoom message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cEnterRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cEnterRoom} s2cEnterRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cEnterRoom.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cEnterRoom();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.gameWidth = reader.int32();
                    break;
                case 2:
                    message.gameHeight = reader.int32();
                    break;
                case 3:
                    message.roomId = reader.int32();
                    break;
                case 4:
                    message.roomTime = reader.int32();
                    break;
                case 5:
                    message.roomStartTime = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("gameWidth"))
                throw $util.ProtocolError("missing required 'gameWidth'", { instance: message });
            if (!message.hasOwnProperty("gameHeight"))
                throw $util.ProtocolError("missing required 'gameHeight'", { instance: message });
            if (!message.hasOwnProperty("roomId"))
                throw $util.ProtocolError("missing required 'roomId'", { instance: message });
            if (!message.hasOwnProperty("roomTime"))
                throw $util.ProtocolError("missing required 'roomTime'", { instance: message });
            if (!message.hasOwnProperty("roomStartTime"))
                throw $util.ProtocolError("missing required 'roomStartTime'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cEnterRoom message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cEnterRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cEnterRoom} s2cEnterRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cEnterRoom.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cEnterRoom message.
         * @function verify
         * @memberof awesomepackage.s2cEnterRoom
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cEnterRoom.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.gameWidth))
                return "gameWidth: integer expected";
            if (!$util.isInteger(message.gameHeight))
                return "gameHeight: integer expected";
            if (!$util.isInteger(message.roomId))
                return "roomId: integer expected";
            if (!$util.isInteger(message.roomTime))
                return "roomTime: integer expected";
            if (!$util.isInteger(message.roomStartTime) && !(message.roomStartTime && $util.isInteger(message.roomStartTime.low) && $util.isInteger(message.roomStartTime.high)))
                return "roomStartTime: integer|Long expected";
            return null;
        };

        return s2cEnterRoom;
    })();

    awesomepackage.c2sPlayerMove = (function() {

        /**
         * Properties of a c2sPlayerMove.
         * @memberof awesomepackage
         * @interface Ic2sPlayerMove
         * @property {number} account c2sPlayerMove account
         * @property {number} targetx c2sPlayerMove targetx
         * @property {number} targety c2sPlayerMove targety
         * @property {number} x c2sPlayerMove x
         * @property {number} y c2sPlayerMove y
         */

        /**
         * Constructs a new c2sPlayerMove.
         * @memberof awesomepackage
         * @classdesc Represents a c2sPlayerMove.
         * @implements Ic2sPlayerMove
         * @constructor
         * @param {awesomepackage.Ic2sPlayerMove=} [properties] Properties to set
         */
        function c2sPlayerMove(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sPlayerMove account.
         * @member {number} account
         * @memberof awesomepackage.c2sPlayerMove
         * @instance
         */
        c2sPlayerMove.prototype.account = 0;

        /**
         * c2sPlayerMove targetx.
         * @member {number} targetx
         * @memberof awesomepackage.c2sPlayerMove
         * @instance
         */
        c2sPlayerMove.prototype.targetx = 0;

        /**
         * c2sPlayerMove targety.
         * @member {number} targety
         * @memberof awesomepackage.c2sPlayerMove
         * @instance
         */
        c2sPlayerMove.prototype.targety = 0;

        /**
         * c2sPlayerMove x.
         * @member {number} x
         * @memberof awesomepackage.c2sPlayerMove
         * @instance
         */
        c2sPlayerMove.prototype.x = 0;

        /**
         * c2sPlayerMove y.
         * @member {number} y
         * @memberof awesomepackage.c2sPlayerMove
         * @instance
         */
        c2sPlayerMove.prototype.y = 0;

        /**
         * Creates a new c2sPlayerMove instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sPlayerMove
         * @static
         * @param {awesomepackage.Ic2sPlayerMove=} [properties] Properties to set
         * @returns {awesomepackage.c2sPlayerMove} c2sPlayerMove instance
         */
        c2sPlayerMove.create = function create(properties) {
            return new c2sPlayerMove(properties);
        };

        /**
         * Encodes the specified c2sPlayerMove message. Does not implicitly {@link awesomepackage.c2sPlayerMove.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sPlayerMove
         * @static
         * @param {awesomepackage.Ic2sPlayerMove} message c2sPlayerMove message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sPlayerMove.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.targetx);
            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.targety);
            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.x);
            writer.uint32(/* id 5, wireType 0 =*/40).int32(message.y);
            return writer;
        };

        /**
         * Encodes the specified c2sPlayerMove message, length delimited. Does not implicitly {@link awesomepackage.c2sPlayerMove.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sPlayerMove
         * @static
         * @param {awesomepackage.Ic2sPlayerMove} message c2sPlayerMove message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sPlayerMove.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sPlayerMove message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sPlayerMove
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sPlayerMove} c2sPlayerMove
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sPlayerMove.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sPlayerMove();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.targetx = reader.int32();
                    break;
                case 3:
                    message.targety = reader.int32();
                    break;
                case 4:
                    message.x = reader.int32();
                    break;
                case 5:
                    message.y = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("targetx"))
                throw $util.ProtocolError("missing required 'targetx'", { instance: message });
            if (!message.hasOwnProperty("targety"))
                throw $util.ProtocolError("missing required 'targety'", { instance: message });
            if (!message.hasOwnProperty("x"))
                throw $util.ProtocolError("missing required 'x'", { instance: message });
            if (!message.hasOwnProperty("y"))
                throw $util.ProtocolError("missing required 'y'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sPlayerMove message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sPlayerMove
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sPlayerMove} c2sPlayerMove
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sPlayerMove.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sPlayerMove message.
         * @function verify
         * @memberof awesomepackage.c2sPlayerMove
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sPlayerMove.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isInteger(message.targetx))
                return "targetx: integer expected";
            if (!$util.isInteger(message.targety))
                return "targety: integer expected";
            if (!$util.isInteger(message.x))
                return "x: integer expected";
            if (!$util.isInteger(message.y))
                return "y: integer expected";
            return null;
        };

        return c2sPlayerMove;
    })();

    awesomepackage.s2cPlayerMove = (function() {

        /**
         * Properties of a s2cPlayerMove.
         * @memberof awesomepackage
         * @interface Is2cPlayerMove
         * @property {Array.<awesomepackage.IroomPlayerInfo>|null} [userData] s2cPlayerMove userData
         * @property {Array.<awesomepackage.ImLine>|null} [lineData] s2cPlayerMove lineData
         */

        /**
         * Constructs a new s2cPlayerMove.
         * @memberof awesomepackage
         * @classdesc Represents a s2cPlayerMove.
         * @implements Is2cPlayerMove
         * @constructor
         * @param {awesomepackage.Is2cPlayerMove=} [properties] Properties to set
         */
        function s2cPlayerMove(properties) {
            this.userData = [];
            this.lineData = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cPlayerMove userData.
         * @member {Array.<awesomepackage.IroomPlayerInfo>} userData
         * @memberof awesomepackage.s2cPlayerMove
         * @instance
         */
        s2cPlayerMove.prototype.userData = $util.emptyArray;

        /**
         * s2cPlayerMove lineData.
         * @member {Array.<awesomepackage.ImLine>} lineData
         * @memberof awesomepackage.s2cPlayerMove
         * @instance
         */
        s2cPlayerMove.prototype.lineData = $util.emptyArray;

        /**
         * Creates a new s2cPlayerMove instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cPlayerMove
         * @static
         * @param {awesomepackage.Is2cPlayerMove=} [properties] Properties to set
         * @returns {awesomepackage.s2cPlayerMove} s2cPlayerMove instance
         */
        s2cPlayerMove.create = function create(properties) {
            return new s2cPlayerMove(properties);
        };

        /**
         * Encodes the specified s2cPlayerMove message. Does not implicitly {@link awesomepackage.s2cPlayerMove.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cPlayerMove
         * @static
         * @param {awesomepackage.Is2cPlayerMove} message s2cPlayerMove message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cPlayerMove.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.userData != null && message.userData.length)
                for (var i = 0; i < message.userData.length; ++i)
                    $root.awesomepackage.roomPlayerInfo.encode(message.userData[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            if (message.lineData != null && message.lineData.length)
                for (var i = 0; i < message.lineData.length; ++i)
                    $root.awesomepackage.mLine.encode(message.lineData[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified s2cPlayerMove message, length delimited. Does not implicitly {@link awesomepackage.s2cPlayerMove.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cPlayerMove
         * @static
         * @param {awesomepackage.Is2cPlayerMove} message s2cPlayerMove message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cPlayerMove.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cPlayerMove message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cPlayerMove
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cPlayerMove} s2cPlayerMove
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cPlayerMove.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cPlayerMove();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.userData && message.userData.length))
                        message.userData = [];
                    message.userData.push($root.awesomepackage.roomPlayerInfo.decode(reader, reader.uint32()));
                    break;
                case 2:
                    if (!(message.lineData && message.lineData.length))
                        message.lineData = [];
                    message.lineData.push($root.awesomepackage.mLine.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a s2cPlayerMove message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cPlayerMove
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cPlayerMove} s2cPlayerMove
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cPlayerMove.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cPlayerMove message.
         * @function verify
         * @memberof awesomepackage.s2cPlayerMove
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cPlayerMove.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.userData != null && message.hasOwnProperty("userData")) {
                if (!Array.isArray(message.userData))
                    return "userData: array expected";
                for (var i = 0; i < message.userData.length; ++i) {
                    var error = $root.awesomepackage.roomPlayerInfo.verify(message.userData[i]);
                    if (error)
                        return "userData." + error;
                }
            }
            if (message.lineData != null && message.hasOwnProperty("lineData")) {
                if (!Array.isArray(message.lineData))
                    return "lineData: array expected";
                for (var i = 0; i < message.lineData.length; ++i) {
                    var error = $root.awesomepackage.mLine.verify(message.lineData[i]);
                    if (error)
                        return "lineData." + error;
                }
            }
            return null;
        };

        return s2cPlayerMove;
    })();

    awesomepackage.c2sChangtype = (function() {

        /**
         * Properties of a c2sChangtype.
         * @memberof awesomepackage
         * @interface Ic2sChangtype
         * @property {number} account c2sChangtype account
         * @property {string} sign c2sChangtype sign
         */

        /**
         * Constructs a new c2sChangtype.
         * @memberof awesomepackage
         * @classdesc Represents a c2sChangtype.
         * @implements Ic2sChangtype
         * @constructor
         * @param {awesomepackage.Ic2sChangtype=} [properties] Properties to set
         */
        function c2sChangtype(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sChangtype account.
         * @member {number} account
         * @memberof awesomepackage.c2sChangtype
         * @instance
         */
        c2sChangtype.prototype.account = 0;

        /**
         * c2sChangtype sign.
         * @member {string} sign
         * @memberof awesomepackage.c2sChangtype
         * @instance
         */
        c2sChangtype.prototype.sign = "";

        /**
         * Creates a new c2sChangtype instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sChangtype
         * @static
         * @param {awesomepackage.Ic2sChangtype=} [properties] Properties to set
         * @returns {awesomepackage.c2sChangtype} c2sChangtype instance
         */
        c2sChangtype.create = function create(properties) {
            return new c2sChangtype(properties);
        };

        /**
         * Encodes the specified c2sChangtype message. Does not implicitly {@link awesomepackage.c2sChangtype.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sChangtype
         * @static
         * @param {awesomepackage.Ic2sChangtype} message c2sChangtype message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sChangtype.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.sign);
            return writer;
        };

        /**
         * Encodes the specified c2sChangtype message, length delimited. Does not implicitly {@link awesomepackage.c2sChangtype.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sChangtype
         * @static
         * @param {awesomepackage.Ic2sChangtype} message c2sChangtype message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sChangtype.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sChangtype message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sChangtype
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sChangtype} c2sChangtype
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sChangtype.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sChangtype();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.sign = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("sign"))
                throw $util.ProtocolError("missing required 'sign'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sChangtype message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sChangtype
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sChangtype} c2sChangtype
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sChangtype.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sChangtype message.
         * @function verify
         * @memberof awesomepackage.c2sChangtype
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sChangtype.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isString(message.sign))
                return "sign: string expected";
            return null;
        };

        return c2sChangtype;
    })();

    awesomepackage.s2cAllPorp = (function() {

        /**
         * Properties of a s2cAllPorp.
         * @memberof awesomepackage
         * @interface Is2cAllPorp
         * @property {Array.<awesomepackage.ImProp>|null} [propData] s2cAllPorp propData
         */

        /**
         * Constructs a new s2cAllPorp.
         * @memberof awesomepackage
         * @classdesc Represents a s2cAllPorp.
         * @implements Is2cAllPorp
         * @constructor
         * @param {awesomepackage.Is2cAllPorp=} [properties] Properties to set
         */
        function s2cAllPorp(properties) {
            this.propData = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cAllPorp propData.
         * @member {Array.<awesomepackage.ImProp>} propData
         * @memberof awesomepackage.s2cAllPorp
         * @instance
         */
        s2cAllPorp.prototype.propData = $util.emptyArray;

        /**
         * Creates a new s2cAllPorp instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cAllPorp
         * @static
         * @param {awesomepackage.Is2cAllPorp=} [properties] Properties to set
         * @returns {awesomepackage.s2cAllPorp} s2cAllPorp instance
         */
        s2cAllPorp.create = function create(properties) {
            return new s2cAllPorp(properties);
        };

        /**
         * Encodes the specified s2cAllPorp message. Does not implicitly {@link awesomepackage.s2cAllPorp.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cAllPorp
         * @static
         * @param {awesomepackage.Is2cAllPorp} message s2cAllPorp message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cAllPorp.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.propData != null && message.propData.length)
                for (var i = 0; i < message.propData.length; ++i)
                    $root.awesomepackage.mProp.encode(message.propData[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified s2cAllPorp message, length delimited. Does not implicitly {@link awesomepackage.s2cAllPorp.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cAllPorp
         * @static
         * @param {awesomepackage.Is2cAllPorp} message s2cAllPorp message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cAllPorp.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cAllPorp message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cAllPorp
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cAllPorp} s2cAllPorp
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cAllPorp.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cAllPorp();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.propData && message.propData.length))
                        message.propData = [];
                    message.propData.push($root.awesomepackage.mProp.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            return message;
        };

        /**
         * Decodes a s2cAllPorp message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cAllPorp
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cAllPorp} s2cAllPorp
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cAllPorp.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cAllPorp message.
         * @function verify
         * @memberof awesomepackage.s2cAllPorp
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cAllPorp.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.propData != null && message.hasOwnProperty("propData")) {
                if (!Array.isArray(message.propData))
                    return "propData: array expected";
                for (var i = 0; i < message.propData.length; ++i) {
                    var error = $root.awesomepackage.mProp.verify(message.propData[i]);
                    if (error)
                        return "propData." + error;
                }
            }
            return null;
        };

        return s2cAllPorp;
    })();

    awesomepackage.c2sBackToHall = (function() {

        /**
         * Properties of a c2sBackToHall.
         * @memberof awesomepackage
         * @interface Ic2sBackToHall
         * @property {number} account c2sBackToHall account
         * @property {string} sign c2sBackToHall sign
         */

        /**
         * Constructs a new c2sBackToHall.
         * @memberof awesomepackage
         * @classdesc Represents a c2sBackToHall.
         * @implements Ic2sBackToHall
         * @constructor
         * @param {awesomepackage.Ic2sBackToHall=} [properties] Properties to set
         */
        function c2sBackToHall(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sBackToHall account.
         * @member {number} account
         * @memberof awesomepackage.c2sBackToHall
         * @instance
         */
        c2sBackToHall.prototype.account = 0;

        /**
         * c2sBackToHall sign.
         * @member {string} sign
         * @memberof awesomepackage.c2sBackToHall
         * @instance
         */
        c2sBackToHall.prototype.sign = "";

        /**
         * Creates a new c2sBackToHall instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sBackToHall
         * @static
         * @param {awesomepackage.Ic2sBackToHall=} [properties] Properties to set
         * @returns {awesomepackage.c2sBackToHall} c2sBackToHall instance
         */
        c2sBackToHall.create = function create(properties) {
            return new c2sBackToHall(properties);
        };

        /**
         * Encodes the specified c2sBackToHall message. Does not implicitly {@link awesomepackage.c2sBackToHall.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sBackToHall
         * @static
         * @param {awesomepackage.Ic2sBackToHall} message c2sBackToHall message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sBackToHall.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.sign);
            return writer;
        };

        /**
         * Encodes the specified c2sBackToHall message, length delimited. Does not implicitly {@link awesomepackage.c2sBackToHall.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sBackToHall
         * @static
         * @param {awesomepackage.Ic2sBackToHall} message c2sBackToHall message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sBackToHall.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sBackToHall message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sBackToHall
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sBackToHall} c2sBackToHall
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sBackToHall.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sBackToHall();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.sign = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("sign"))
                throw $util.ProtocolError("missing required 'sign'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sBackToHall message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sBackToHall
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sBackToHall} c2sBackToHall
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sBackToHall.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sBackToHall message.
         * @function verify
         * @memberof awesomepackage.c2sBackToHall
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sBackToHall.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isString(message.sign))
                return "sign: string expected";
            return null;
        };

        return c2sBackToHall;
    })();

    awesomepackage.c2sRespawn = (function() {

        /**
         * Properties of a c2sRespawn.
         * @memberof awesomepackage
         * @interface Ic2sRespawn
         * @property {number} account c2sRespawn account
         * @property {string} sign c2sRespawn sign
         * @property {number} roomId c2sRespawn roomId
         */

        /**
         * Constructs a new c2sRespawn.
         * @memberof awesomepackage
         * @classdesc Represents a c2sRespawn.
         * @implements Ic2sRespawn
         * @constructor
         * @param {awesomepackage.Ic2sRespawn=} [properties] Properties to set
         */
        function c2sRespawn(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sRespawn account.
         * @member {number} account
         * @memberof awesomepackage.c2sRespawn
         * @instance
         */
        c2sRespawn.prototype.account = 0;

        /**
         * c2sRespawn sign.
         * @member {string} sign
         * @memberof awesomepackage.c2sRespawn
         * @instance
         */
        c2sRespawn.prototype.sign = "";

        /**
         * c2sRespawn roomId.
         * @member {number} roomId
         * @memberof awesomepackage.c2sRespawn
         * @instance
         */
        c2sRespawn.prototype.roomId = 0;

        /**
         * Creates a new c2sRespawn instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sRespawn
         * @static
         * @param {awesomepackage.Ic2sRespawn=} [properties] Properties to set
         * @returns {awesomepackage.c2sRespawn} c2sRespawn instance
         */
        c2sRespawn.create = function create(properties) {
            return new c2sRespawn(properties);
        };

        /**
         * Encodes the specified c2sRespawn message. Does not implicitly {@link awesomepackage.c2sRespawn.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sRespawn
         * @static
         * @param {awesomepackage.Ic2sRespawn} message c2sRespawn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sRespawn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.sign);
            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.roomId);
            return writer;
        };

        /**
         * Encodes the specified c2sRespawn message, length delimited. Does not implicitly {@link awesomepackage.c2sRespawn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sRespawn
         * @static
         * @param {awesomepackage.Ic2sRespawn} message c2sRespawn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sRespawn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sRespawn message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sRespawn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sRespawn} c2sRespawn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sRespawn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sRespawn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.sign = reader.string();
                    break;
                case 3:
                    message.roomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("sign"))
                throw $util.ProtocolError("missing required 'sign'", { instance: message });
            if (!message.hasOwnProperty("roomId"))
                throw $util.ProtocolError("missing required 'roomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sRespawn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sRespawn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sRespawn} c2sRespawn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sRespawn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sRespawn message.
         * @function verify
         * @memberof awesomepackage.c2sRespawn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sRespawn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isString(message.sign))
                return "sign: string expected";
            if (!$util.isInteger(message.roomId))
                return "roomId: integer expected";
            return null;
        };

        return c2sRespawn;
    })();

    awesomepackage.s2cRespawn = (function() {

        /**
         * Properties of a s2cRespawn.
         * @memberof awesomepackage
         * @interface Is2cRespawn
         * @property {number|Long} startRoomTime s2cRespawn startRoomTime
         */

        /**
         * Constructs a new s2cRespawn.
         * @memberof awesomepackage
         * @classdesc Represents a s2cRespawn.
         * @implements Is2cRespawn
         * @constructor
         * @param {awesomepackage.Is2cRespawn=} [properties] Properties to set
         */
        function s2cRespawn(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cRespawn startRoomTime.
         * @member {number|Long} startRoomTime
         * @memberof awesomepackage.s2cRespawn
         * @instance
         */
        s2cRespawn.prototype.startRoomTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

        /**
         * Creates a new s2cRespawn instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cRespawn
         * @static
         * @param {awesomepackage.Is2cRespawn=} [properties] Properties to set
         * @returns {awesomepackage.s2cRespawn} s2cRespawn instance
         */
        s2cRespawn.create = function create(properties) {
            return new s2cRespawn(properties);
        };

        /**
         * Encodes the specified s2cRespawn message. Does not implicitly {@link awesomepackage.s2cRespawn.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cRespawn
         * @static
         * @param {awesomepackage.Is2cRespawn} message s2cRespawn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cRespawn.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int64(message.startRoomTime);
            return writer;
        };

        /**
         * Encodes the specified s2cRespawn message, length delimited. Does not implicitly {@link awesomepackage.s2cRespawn.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cRespawn
         * @static
         * @param {awesomepackage.Is2cRespawn} message s2cRespawn message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cRespawn.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cRespawn message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cRespawn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cRespawn} s2cRespawn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cRespawn.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cRespawn();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.startRoomTime = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("startRoomTime"))
                throw $util.ProtocolError("missing required 'startRoomTime'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cRespawn message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cRespawn
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cRespawn} s2cRespawn
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cRespawn.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cRespawn message.
         * @function verify
         * @memberof awesomepackage.s2cRespawn
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cRespawn.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.startRoomTime) && !(message.startRoomTime && $util.isInteger(message.startRoomTime.low) && $util.isInteger(message.startRoomTime.high)))
                return "startRoomTime: integer|Long expected";
            return null;
        };

        return s2cRespawn;
    })();

    awesomepackage.s2cTopList = (function() {

        /**
         * Properties of a s2cTopList.
         * @memberof awesomepackage
         * @interface Is2cTopList
         * @property {Array.<awesomepackage.ItopUsrItem>|null} [tops] s2cTopList tops
         * @property {awesomepackage.ItopUsrItem} min s2cTopList min
         */

        /**
         * Constructs a new s2cTopList.
         * @memberof awesomepackage
         * @classdesc Represents a s2cTopList.
         * @implements Is2cTopList
         * @constructor
         * @param {awesomepackage.Is2cTopList=} [properties] Properties to set
         */
        function s2cTopList(properties) {
            this.tops = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cTopList tops.
         * @member {Array.<awesomepackage.ItopUsrItem>} tops
         * @memberof awesomepackage.s2cTopList
         * @instance
         */
        s2cTopList.prototype.tops = $util.emptyArray;

        /**
         * s2cTopList min.
         * @member {awesomepackage.ItopUsrItem} min
         * @memberof awesomepackage.s2cTopList
         * @instance
         */
        s2cTopList.prototype.min = null;

        /**
         * Creates a new s2cTopList instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cTopList
         * @static
         * @param {awesomepackage.Is2cTopList=} [properties] Properties to set
         * @returns {awesomepackage.s2cTopList} s2cTopList instance
         */
        s2cTopList.create = function create(properties) {
            return new s2cTopList(properties);
        };

        /**
         * Encodes the specified s2cTopList message. Does not implicitly {@link awesomepackage.s2cTopList.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cTopList
         * @static
         * @param {awesomepackage.Is2cTopList} message s2cTopList message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cTopList.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.tops != null && message.tops.length)
                for (var i = 0; i < message.tops.length; ++i)
                    $root.awesomepackage.topUsrItem.encode(message.tops[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            $root.awesomepackage.topUsrItem.encode(message.min, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified s2cTopList message, length delimited. Does not implicitly {@link awesomepackage.s2cTopList.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cTopList
         * @static
         * @param {awesomepackage.Is2cTopList} message s2cTopList message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cTopList.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cTopList message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cTopList
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cTopList} s2cTopList
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cTopList.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cTopList();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.tops && message.tops.length))
                        message.tops = [];
                    message.tops.push($root.awesomepackage.topUsrItem.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.min = $root.awesomepackage.topUsrItem.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("min"))
                throw $util.ProtocolError("missing required 'min'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cTopList message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cTopList
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cTopList} s2cTopList
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cTopList.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cTopList message.
         * @function verify
         * @memberof awesomepackage.s2cTopList
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cTopList.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.tops != null && message.hasOwnProperty("tops")) {
                if (!Array.isArray(message.tops))
                    return "tops: array expected";
                for (var i = 0; i < message.tops.length; ++i) {
                    var error = $root.awesomepackage.topUsrItem.verify(message.tops[i]);
                    if (error)
                        return "tops." + error;
                }
            }
            {
                var error = $root.awesomepackage.topUsrItem.verify(message.min);
                if (error)
                    return "min." + error;
            }
            return null;
        };

        return s2cTopList;
    })();

    awesomepackage.s2cGameOver = (function() {

        /**
         * Properties of a s2cGameOver.
         * @memberof awesomepackage
         * @interface Is2cGameOver
         * @property {Array.<awesomepackage.ItopUsrItem>|null} [roomUser] s2cGameOver roomUser
         * @property {number} roomId s2cGameOver roomId
         */

        /**
         * Constructs a new s2cGameOver.
         * @memberof awesomepackage
         * @classdesc Represents a s2cGameOver.
         * @implements Is2cGameOver
         * @constructor
         * @param {awesomepackage.Is2cGameOver=} [properties] Properties to set
         */
        function s2cGameOver(properties) {
            this.roomUser = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cGameOver roomUser.
         * @member {Array.<awesomepackage.ItopUsrItem>} roomUser
         * @memberof awesomepackage.s2cGameOver
         * @instance
         */
        s2cGameOver.prototype.roomUser = $util.emptyArray;

        /**
         * s2cGameOver roomId.
         * @member {number} roomId
         * @memberof awesomepackage.s2cGameOver
         * @instance
         */
        s2cGameOver.prototype.roomId = 0;

        /**
         * Creates a new s2cGameOver instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cGameOver
         * @static
         * @param {awesomepackage.Is2cGameOver=} [properties] Properties to set
         * @returns {awesomepackage.s2cGameOver} s2cGameOver instance
         */
        s2cGameOver.create = function create(properties) {
            return new s2cGameOver(properties);
        };

        /**
         * Encodes the specified s2cGameOver message. Does not implicitly {@link awesomepackage.s2cGameOver.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cGameOver
         * @static
         * @param {awesomepackage.Is2cGameOver} message s2cGameOver message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cGameOver.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            if (message.roomUser != null && message.roomUser.length)
                for (var i = 0; i < message.roomUser.length; ++i)
                    $root.awesomepackage.topUsrItem.encode(message.roomUser[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.roomId);
            return writer;
        };

        /**
         * Encodes the specified s2cGameOver message, length delimited. Does not implicitly {@link awesomepackage.s2cGameOver.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cGameOver
         * @static
         * @param {awesomepackage.Is2cGameOver} message s2cGameOver message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cGameOver.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cGameOver message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cGameOver
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cGameOver} s2cGameOver
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cGameOver.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cGameOver();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    if (!(message.roomUser && message.roomUser.length))
                        message.roomUser = [];
                    message.roomUser.push($root.awesomepackage.topUsrItem.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.roomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("roomId"))
                throw $util.ProtocolError("missing required 'roomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cGameOver message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cGameOver
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cGameOver} s2cGameOver
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cGameOver.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cGameOver message.
         * @function verify
         * @memberof awesomepackage.s2cGameOver
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cGameOver.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (message.roomUser != null && message.hasOwnProperty("roomUser")) {
                if (!Array.isArray(message.roomUser))
                    return "roomUser: array expected";
                for (var i = 0; i < message.roomUser.length; ++i) {
                    var error = $root.awesomepackage.topUsrItem.verify(message.roomUser[i]);
                    if (error)
                        return "roomUser." + error;
                }
            }
            if (!$util.isInteger(message.roomId))
                return "roomId: integer expected";
            return null;
        };

        return s2cGameOver;
    })();

    awesomepackage.c2soutRoom = (function() {

        /**
         * Properties of a c2soutRoom.
         * @memberof awesomepackage
         * @interface Ic2soutRoom
         * @property {number} account c2soutRoom account
         * @property {number} roomId c2soutRoom roomId
         */

        /**
         * Constructs a new c2soutRoom.
         * @memberof awesomepackage
         * @classdesc Represents a c2soutRoom.
         * @implements Ic2soutRoom
         * @constructor
         * @param {awesomepackage.Ic2soutRoom=} [properties] Properties to set
         */
        function c2soutRoom(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2soutRoom account.
         * @member {number} account
         * @memberof awesomepackage.c2soutRoom
         * @instance
         */
        c2soutRoom.prototype.account = 0;

        /**
         * c2soutRoom roomId.
         * @member {number} roomId
         * @memberof awesomepackage.c2soutRoom
         * @instance
         */
        c2soutRoom.prototype.roomId = 0;

        /**
         * Creates a new c2soutRoom instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2soutRoom
         * @static
         * @param {awesomepackage.Ic2soutRoom=} [properties] Properties to set
         * @returns {awesomepackage.c2soutRoom} c2soutRoom instance
         */
        c2soutRoom.create = function create(properties) {
            return new c2soutRoom(properties);
        };

        /**
         * Encodes the specified c2soutRoom message. Does not implicitly {@link awesomepackage.c2soutRoom.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2soutRoom
         * @static
         * @param {awesomepackage.Ic2soutRoom} message c2soutRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2soutRoom.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.roomId);
            return writer;
        };

        /**
         * Encodes the specified c2soutRoom message, length delimited. Does not implicitly {@link awesomepackage.c2soutRoom.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2soutRoom
         * @static
         * @param {awesomepackage.Ic2soutRoom} message c2soutRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2soutRoom.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2soutRoom message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2soutRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2soutRoom} c2soutRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2soutRoom.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2soutRoom();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.roomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("roomId"))
                throw $util.ProtocolError("missing required 'roomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2soutRoom message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2soutRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2soutRoom} c2soutRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2soutRoom.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2soutRoom message.
         * @function verify
         * @memberof awesomepackage.c2soutRoom
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2soutRoom.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isInteger(message.roomId))
                return "roomId: integer expected";
            return null;
        };

        return c2soutRoom;
    })();

    awesomepackage.c2sShoot = (function() {

        /**
         * Properties of a c2sShoot.
         * @memberof awesomepackage
         * @interface Ic2sShoot
         * @property {number} account c2sShoot account
         * @property {number} roomId c2sShoot roomId
         * @property {number} dirX c2sShoot dirX
         * @property {number} dirY c2sShoot dirY
         */

        /**
         * Constructs a new c2sShoot.
         * @memberof awesomepackage
         * @classdesc Represents a c2sShoot.
         * @implements Ic2sShoot
         * @constructor
         * @param {awesomepackage.Ic2sShoot=} [properties] Properties to set
         */
        function c2sShoot(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sShoot account.
         * @member {number} account
         * @memberof awesomepackage.c2sShoot
         * @instance
         */
        c2sShoot.prototype.account = 0;

        /**
         * c2sShoot roomId.
         * @member {number} roomId
         * @memberof awesomepackage.c2sShoot
         * @instance
         */
        c2sShoot.prototype.roomId = 0;

        /**
         * c2sShoot dirX.
         * @member {number} dirX
         * @memberof awesomepackage.c2sShoot
         * @instance
         */
        c2sShoot.prototype.dirX = 0;

        /**
         * c2sShoot dirY.
         * @member {number} dirY
         * @memberof awesomepackage.c2sShoot
         * @instance
         */
        c2sShoot.prototype.dirY = 0;

        /**
         * Creates a new c2sShoot instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sShoot
         * @static
         * @param {awesomepackage.Ic2sShoot=} [properties] Properties to set
         * @returns {awesomepackage.c2sShoot} c2sShoot instance
         */
        c2sShoot.create = function create(properties) {
            return new c2sShoot(properties);
        };

        /**
         * Encodes the specified c2sShoot message. Does not implicitly {@link awesomepackage.c2sShoot.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sShoot
         * @static
         * @param {awesomepackage.Ic2sShoot} message c2sShoot message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sShoot.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.roomId);
            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.dirX);
            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.dirY);
            return writer;
        };

        /**
         * Encodes the specified c2sShoot message, length delimited. Does not implicitly {@link awesomepackage.c2sShoot.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sShoot
         * @static
         * @param {awesomepackage.Ic2sShoot} message c2sShoot message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sShoot.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sShoot message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sShoot
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sShoot} c2sShoot
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sShoot.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sShoot();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.roomId = reader.int32();
                    break;
                case 3:
                    message.dirX = reader.int32();
                    break;
                case 4:
                    message.dirY = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("roomId"))
                throw $util.ProtocolError("missing required 'roomId'", { instance: message });
            if (!message.hasOwnProperty("dirX"))
                throw $util.ProtocolError("missing required 'dirX'", { instance: message });
            if (!message.hasOwnProperty("dirY"))
                throw $util.ProtocolError("missing required 'dirY'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sShoot message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sShoot
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sShoot} c2sShoot
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sShoot.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sShoot message.
         * @function verify
         * @memberof awesomepackage.c2sShoot
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sShoot.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isInteger(message.roomId))
                return "roomId: integer expected";
            if (!$util.isInteger(message.dirX))
                return "dirX: integer expected";
            if (!$util.isInteger(message.dirY))
                return "dirY: integer expected";
            return null;
        };

        return c2sShoot;
    })();

    awesomepackage.s2cShoot = (function() {

        /**
         * Properties of a s2cShoot.
         * @memberof awesomepackage
         * @interface Is2cShoot
         * @property {number} account s2cShoot account
         * @property {number} shootObjStates s2cShoot shootObjStates
         * @property {number|null} [x] s2cShoot x
         * @property {number|null} [y] s2cShoot y
         */

        /**
         * Constructs a new s2cShoot.
         * @memberof awesomepackage
         * @classdesc Represents a s2cShoot.
         * @implements Is2cShoot
         * @constructor
         * @param {awesomepackage.Is2cShoot=} [properties] Properties to set
         */
        function s2cShoot(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cShoot account.
         * @member {number} account
         * @memberof awesomepackage.s2cShoot
         * @instance
         */
        s2cShoot.prototype.account = 0;

        /**
         * s2cShoot shootObjStates.
         * @member {number} shootObjStates
         * @memberof awesomepackage.s2cShoot
         * @instance
         */
        s2cShoot.prototype.shootObjStates = 0;

        /**
         * s2cShoot x.
         * @member {number} x
         * @memberof awesomepackage.s2cShoot
         * @instance
         */
        s2cShoot.prototype.x = 0;

        /**
         * s2cShoot y.
         * @member {number} y
         * @memberof awesomepackage.s2cShoot
         * @instance
         */
        s2cShoot.prototype.y = 0;

        /**
         * Creates a new s2cShoot instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cShoot
         * @static
         * @param {awesomepackage.Is2cShoot=} [properties] Properties to set
         * @returns {awesomepackage.s2cShoot} s2cShoot instance
         */
        s2cShoot.create = function create(properties) {
            return new s2cShoot(properties);
        };

        /**
         * Encodes the specified s2cShoot message. Does not implicitly {@link awesomepackage.s2cShoot.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cShoot
         * @static
         * @param {awesomepackage.Is2cShoot} message s2cShoot message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cShoot.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.shootObjStates);
            if (message.x != null && message.hasOwnProperty("x"))
                writer.uint32(/* id 3, wireType 0 =*/24).int32(message.x);
            if (message.y != null && message.hasOwnProperty("y"))
                writer.uint32(/* id 4, wireType 0 =*/32).int32(message.y);
            return writer;
        };

        /**
         * Encodes the specified s2cShoot message, length delimited. Does not implicitly {@link awesomepackage.s2cShoot.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cShoot
         * @static
         * @param {awesomepackage.Is2cShoot} message s2cShoot message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cShoot.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cShoot message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cShoot
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cShoot} s2cShoot
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cShoot.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cShoot();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.shootObjStates = reader.int32();
                    break;
                case 3:
                    message.x = reader.int32();
                    break;
                case 4:
                    message.y = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("shootObjStates"))
                throw $util.ProtocolError("missing required 'shootObjStates'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cShoot message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cShoot
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cShoot} s2cShoot
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cShoot.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cShoot message.
         * @function verify
         * @memberof awesomepackage.s2cShoot
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cShoot.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isInteger(message.shootObjStates))
                return "shootObjStates: integer expected";
            if (message.x != null && message.hasOwnProperty("x"))
                if (!$util.isInteger(message.x))
                    return "x: integer expected";
            if (message.y != null && message.hasOwnProperty("y"))
                if (!$util.isInteger(message.y))
                    return "y: integer expected";
            return null;
        };

        return s2cShoot;
    })();

    awesomepackage.c2sDisconnect = (function() {

        /**
         * Properties of a c2sDisconnect.
         * @memberof awesomepackage
         * @interface Ic2sDisconnect
         * @property {number} account c2sDisconnect account
         * @property {number} roomId c2sDisconnect roomId
         */

        /**
         * Constructs a new c2sDisconnect.
         * @memberof awesomepackage
         * @classdesc Represents a c2sDisconnect.
         * @implements Ic2sDisconnect
         * @constructor
         * @param {awesomepackage.Ic2sDisconnect=} [properties] Properties to set
         */
        function c2sDisconnect(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sDisconnect account.
         * @member {number} account
         * @memberof awesomepackage.c2sDisconnect
         * @instance
         */
        c2sDisconnect.prototype.account = 0;

        /**
         * c2sDisconnect roomId.
         * @member {number} roomId
         * @memberof awesomepackage.c2sDisconnect
         * @instance
         */
        c2sDisconnect.prototype.roomId = 0;

        /**
         * Creates a new c2sDisconnect instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sDisconnect
         * @static
         * @param {awesomepackage.Ic2sDisconnect=} [properties] Properties to set
         * @returns {awesomepackage.c2sDisconnect} c2sDisconnect instance
         */
        c2sDisconnect.create = function create(properties) {
            return new c2sDisconnect(properties);
        };

        /**
         * Encodes the specified c2sDisconnect message. Does not implicitly {@link awesomepackage.c2sDisconnect.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sDisconnect
         * @static
         * @param {awesomepackage.Ic2sDisconnect} message c2sDisconnect message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sDisconnect.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.roomId);
            return writer;
        };

        /**
         * Encodes the specified c2sDisconnect message, length delimited. Does not implicitly {@link awesomepackage.c2sDisconnect.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sDisconnect
         * @static
         * @param {awesomepackage.Ic2sDisconnect} message c2sDisconnect message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sDisconnect.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sDisconnect message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sDisconnect
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sDisconnect} c2sDisconnect
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sDisconnect.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sDisconnect();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.roomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("roomId"))
                throw $util.ProtocolError("missing required 'roomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sDisconnect message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sDisconnect
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sDisconnect} c2sDisconnect
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sDisconnect.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sDisconnect message.
         * @function verify
         * @memberof awesomepackage.c2sDisconnect
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sDisconnect.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isInteger(message.roomId))
                return "roomId: integer expected";
            return null;
        };

        return c2sDisconnect;
    })();

    awesomepackage.c2sEnterInvoteRoom = (function() {

        /**
         * Properties of a c2sEnterInvoteRoom.
         * @memberof awesomepackage
         * @interface Ic2sEnterInvoteRoom
         * @property {number} account c2sEnterInvoteRoom account
         * @property {number|null} [waitRoomId] c2sEnterInvoteRoom waitRoomId
         */

        /**
         * Constructs a new c2sEnterInvoteRoom.
         * @memberof awesomepackage
         * @classdesc Represents a c2sEnterInvoteRoom.
         * @implements Ic2sEnterInvoteRoom
         * @constructor
         * @param {awesomepackage.Ic2sEnterInvoteRoom=} [properties] Properties to set
         */
        function c2sEnterInvoteRoom(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sEnterInvoteRoom account.
         * @member {number} account
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @instance
         */
        c2sEnterInvoteRoom.prototype.account = 0;

        /**
         * c2sEnterInvoteRoom waitRoomId.
         * @member {number} waitRoomId
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @instance
         */
        c2sEnterInvoteRoom.prototype.waitRoomId = 0;

        /**
         * Creates a new c2sEnterInvoteRoom instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @static
         * @param {awesomepackage.Ic2sEnterInvoteRoom=} [properties] Properties to set
         * @returns {awesomepackage.c2sEnterInvoteRoom} c2sEnterInvoteRoom instance
         */
        c2sEnterInvoteRoom.create = function create(properties) {
            return new c2sEnterInvoteRoom(properties);
        };

        /**
         * Encodes the specified c2sEnterInvoteRoom message. Does not implicitly {@link awesomepackage.c2sEnterInvoteRoom.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @static
         * @param {awesomepackage.Ic2sEnterInvoteRoom} message c2sEnterInvoteRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sEnterInvoteRoom.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            if (message.waitRoomId != null && message.hasOwnProperty("waitRoomId"))
                writer.uint32(/* id 2, wireType 0 =*/16).int32(message.waitRoomId);
            return writer;
        };

        /**
         * Encodes the specified c2sEnterInvoteRoom message, length delimited. Does not implicitly {@link awesomepackage.c2sEnterInvoteRoom.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @static
         * @param {awesomepackage.Ic2sEnterInvoteRoom} message c2sEnterInvoteRoom message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sEnterInvoteRoom.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sEnterInvoteRoom message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sEnterInvoteRoom} c2sEnterInvoteRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sEnterInvoteRoom.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sEnterInvoteRoom();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.waitRoomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sEnterInvoteRoom message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sEnterInvoteRoom} c2sEnterInvoteRoom
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sEnterInvoteRoom.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sEnterInvoteRoom message.
         * @function verify
         * @memberof awesomepackage.c2sEnterInvoteRoom
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sEnterInvoteRoom.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (message.waitRoomId != null && message.hasOwnProperty("waitRoomId"))
                if (!$util.isInteger(message.waitRoomId))
                    return "waitRoomId: integer expected";
            return null;
        };

        return c2sEnterInvoteRoom;
    })();

    awesomepackage.s2cEnterInvoteRoomSuc = (function() {

        /**
         * Properties of a s2cEnterInvoteRoomSuc.
         * @memberof awesomepackage
         * @interface Is2cEnterInvoteRoomSuc
         * @property {number} waitRoomId s2cEnterInvoteRoomSuc waitRoomId
         */

        /**
         * Constructs a new s2cEnterInvoteRoomSuc.
         * @memberof awesomepackage
         * @classdesc Represents a s2cEnterInvoteRoomSuc.
         * @implements Is2cEnterInvoteRoomSuc
         * @constructor
         * @param {awesomepackage.Is2cEnterInvoteRoomSuc=} [properties] Properties to set
         */
        function s2cEnterInvoteRoomSuc(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cEnterInvoteRoomSuc waitRoomId.
         * @member {number} waitRoomId
         * @memberof awesomepackage.s2cEnterInvoteRoomSuc
         * @instance
         */
        s2cEnterInvoteRoomSuc.prototype.waitRoomId = 0;

        /**
         * Creates a new s2cEnterInvoteRoomSuc instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cEnterInvoteRoomSuc
         * @static
         * @param {awesomepackage.Is2cEnterInvoteRoomSuc=} [properties] Properties to set
         * @returns {awesomepackage.s2cEnterInvoteRoomSuc} s2cEnterInvoteRoomSuc instance
         */
        s2cEnterInvoteRoomSuc.create = function create(properties) {
            return new s2cEnterInvoteRoomSuc(properties);
        };

        /**
         * Encodes the specified s2cEnterInvoteRoomSuc message. Does not implicitly {@link awesomepackage.s2cEnterInvoteRoomSuc.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cEnterInvoteRoomSuc
         * @static
         * @param {awesomepackage.Is2cEnterInvoteRoomSuc} message s2cEnterInvoteRoomSuc message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cEnterInvoteRoomSuc.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.waitRoomId);
            return writer;
        };

        /**
         * Encodes the specified s2cEnterInvoteRoomSuc message, length delimited. Does not implicitly {@link awesomepackage.s2cEnterInvoteRoomSuc.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cEnterInvoteRoomSuc
         * @static
         * @param {awesomepackage.Is2cEnterInvoteRoomSuc} message s2cEnterInvoteRoomSuc message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cEnterInvoteRoomSuc.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cEnterInvoteRoomSuc message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cEnterInvoteRoomSuc
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cEnterInvoteRoomSuc} s2cEnterInvoteRoomSuc
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cEnterInvoteRoomSuc.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cEnterInvoteRoomSuc();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.waitRoomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("waitRoomId"))
                throw $util.ProtocolError("missing required 'waitRoomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cEnterInvoteRoomSuc message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cEnterInvoteRoomSuc
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cEnterInvoteRoomSuc} s2cEnterInvoteRoomSuc
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cEnterInvoteRoomSuc.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cEnterInvoteRoomSuc message.
         * @function verify
         * @memberof awesomepackage.s2cEnterInvoteRoomSuc
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cEnterInvoteRoomSuc.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.waitRoomId))
                return "waitRoomId: integer expected";
            return null;
        };

        return s2cEnterInvoteRoomSuc;
    })();

    awesomepackage.c2SInvoteRoomInfo = (function() {

        /**
         * Properties of a c2SInvoteRoomInfo.
         * @memberof awesomepackage
         * @interface Ic2SInvoteRoomInfo
         * @property {number} account c2SInvoteRoomInfo account
         * @property {number} waitRoomId c2SInvoteRoomInfo waitRoomId
         */

        /**
         * Constructs a new c2SInvoteRoomInfo.
         * @memberof awesomepackage
         * @classdesc Represents a c2SInvoteRoomInfo.
         * @implements Ic2SInvoteRoomInfo
         * @constructor
         * @param {awesomepackage.Ic2SInvoteRoomInfo=} [properties] Properties to set
         */
        function c2SInvoteRoomInfo(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2SInvoteRoomInfo account.
         * @member {number} account
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @instance
         */
        c2SInvoteRoomInfo.prototype.account = 0;

        /**
         * c2SInvoteRoomInfo waitRoomId.
         * @member {number} waitRoomId
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @instance
         */
        c2SInvoteRoomInfo.prototype.waitRoomId = 0;

        /**
         * Creates a new c2SInvoteRoomInfo instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @static
         * @param {awesomepackage.Ic2SInvoteRoomInfo=} [properties] Properties to set
         * @returns {awesomepackage.c2SInvoteRoomInfo} c2SInvoteRoomInfo instance
         */
        c2SInvoteRoomInfo.create = function create(properties) {
            return new c2SInvoteRoomInfo(properties);
        };

        /**
         * Encodes the specified c2SInvoteRoomInfo message. Does not implicitly {@link awesomepackage.c2SInvoteRoomInfo.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @static
         * @param {awesomepackage.Ic2SInvoteRoomInfo} message c2SInvoteRoomInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2SInvoteRoomInfo.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.account);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.waitRoomId);
            return writer;
        };

        /**
         * Encodes the specified c2SInvoteRoomInfo message, length delimited. Does not implicitly {@link awesomepackage.c2SInvoteRoomInfo.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @static
         * @param {awesomepackage.Ic2SInvoteRoomInfo} message c2SInvoteRoomInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2SInvoteRoomInfo.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2SInvoteRoomInfo message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2SInvoteRoomInfo} c2SInvoteRoomInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2SInvoteRoomInfo.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2SInvoteRoomInfo();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.account = reader.int32();
                    break;
                case 2:
                    message.waitRoomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            if (!message.hasOwnProperty("waitRoomId"))
                throw $util.ProtocolError("missing required 'waitRoomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2SInvoteRoomInfo message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2SInvoteRoomInfo} c2SInvoteRoomInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2SInvoteRoomInfo.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2SInvoteRoomInfo message.
         * @function verify
         * @memberof awesomepackage.c2SInvoteRoomInfo
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2SInvoteRoomInfo.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            if (!$util.isInteger(message.waitRoomId))
                return "waitRoomId: integer expected";
            return null;
        };

        return c2SInvoteRoomInfo;
    })();

    awesomepackage.s2cInvoteRoomInfo = (function() {

        /**
         * Properties of a s2cInvoteRoomInfo.
         * @memberof awesomepackage
         * @interface Is2cInvoteRoomInfo
         * @property {number} waitRoomId s2cInvoteRoomInfo waitRoomId
         * @property {Array.<awesomepackage.IinvotePlayerInfo>|null} [players] s2cInvoteRoomInfo players
         */

        /**
         * Constructs a new s2cInvoteRoomInfo.
         * @memberof awesomepackage
         * @classdesc Represents a s2cInvoteRoomInfo.
         * @implements Is2cInvoteRoomInfo
         * @constructor
         * @param {awesomepackage.Is2cInvoteRoomInfo=} [properties] Properties to set
         */
        function s2cInvoteRoomInfo(properties) {
            this.players = [];
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cInvoteRoomInfo waitRoomId.
         * @member {number} waitRoomId
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @instance
         */
        s2cInvoteRoomInfo.prototype.waitRoomId = 0;

        /**
         * s2cInvoteRoomInfo players.
         * @member {Array.<awesomepackage.IinvotePlayerInfo>} players
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @instance
         */
        s2cInvoteRoomInfo.prototype.players = $util.emptyArray;

        /**
         * Creates a new s2cInvoteRoomInfo instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @static
         * @param {awesomepackage.Is2cInvoteRoomInfo=} [properties] Properties to set
         * @returns {awesomepackage.s2cInvoteRoomInfo} s2cInvoteRoomInfo instance
         */
        s2cInvoteRoomInfo.create = function create(properties) {
            return new s2cInvoteRoomInfo(properties);
        };

        /**
         * Encodes the specified s2cInvoteRoomInfo message. Does not implicitly {@link awesomepackage.s2cInvoteRoomInfo.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @static
         * @param {awesomepackage.Is2cInvoteRoomInfo} message s2cInvoteRoomInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cInvoteRoomInfo.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.waitRoomId);
            if (message.players != null && message.players.length)
                for (var i = 0; i < message.players.length; ++i)
                    $root.awesomepackage.invotePlayerInfo.encode(message.players[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified s2cInvoteRoomInfo message, length delimited. Does not implicitly {@link awesomepackage.s2cInvoteRoomInfo.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @static
         * @param {awesomepackage.Is2cInvoteRoomInfo} message s2cInvoteRoomInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cInvoteRoomInfo.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cInvoteRoomInfo message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cInvoteRoomInfo} s2cInvoteRoomInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cInvoteRoomInfo.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cInvoteRoomInfo();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.waitRoomId = reader.int32();
                    break;
                case 2:
                    if (!(message.players && message.players.length))
                        message.players = [];
                    message.players.push($root.awesomepackage.invotePlayerInfo.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("waitRoomId"))
                throw $util.ProtocolError("missing required 'waitRoomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cInvoteRoomInfo message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cInvoteRoomInfo} s2cInvoteRoomInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cInvoteRoomInfo.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cInvoteRoomInfo message.
         * @function verify
         * @memberof awesomepackage.s2cInvoteRoomInfo
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cInvoteRoomInfo.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.waitRoomId))
                return "waitRoomId: integer expected";
            if (message.players != null && message.hasOwnProperty("players")) {
                if (!Array.isArray(message.players))
                    return "players: array expected";
                for (var i = 0; i < message.players.length; ++i) {
                    var error = $root.awesomepackage.invotePlayerInfo.verify(message.players[i]);
                    if (error)
                        return "players." + error;
                }
            }
            return null;
        };

        return s2cInvoteRoomInfo;
    })();

    awesomepackage.invotePlayerInfo = (function() {

        /**
         * Properties of an invotePlayerInfo.
         * @memberof awesomepackage
         * @interface IinvotePlayerInfo
         * @property {string} nickname invotePlayerInfo nickname
         * @property {string} headUrl invotePlayerInfo headUrl
         * @property {boolean} sex invotePlayerInfo sex
         */

        /**
         * Constructs a new invotePlayerInfo.
         * @memberof awesomepackage
         * @classdesc Represents an invotePlayerInfo.
         * @implements IinvotePlayerInfo
         * @constructor
         * @param {awesomepackage.IinvotePlayerInfo=} [properties] Properties to set
         */
        function invotePlayerInfo(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * invotePlayerInfo nickname.
         * @member {string} nickname
         * @memberof awesomepackage.invotePlayerInfo
         * @instance
         */
        invotePlayerInfo.prototype.nickname = "";

        /**
         * invotePlayerInfo headUrl.
         * @member {string} headUrl
         * @memberof awesomepackage.invotePlayerInfo
         * @instance
         */
        invotePlayerInfo.prototype.headUrl = "";

        /**
         * invotePlayerInfo sex.
         * @member {boolean} sex
         * @memberof awesomepackage.invotePlayerInfo
         * @instance
         */
        invotePlayerInfo.prototype.sex = false;

        /**
         * Creates a new invotePlayerInfo instance using the specified properties.
         * @function create
         * @memberof awesomepackage.invotePlayerInfo
         * @static
         * @param {awesomepackage.IinvotePlayerInfo=} [properties] Properties to set
         * @returns {awesomepackage.invotePlayerInfo} invotePlayerInfo instance
         */
        invotePlayerInfo.create = function create(properties) {
            return new invotePlayerInfo(properties);
        };

        /**
         * Encodes the specified invotePlayerInfo message. Does not implicitly {@link awesomepackage.invotePlayerInfo.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.invotePlayerInfo
         * @static
         * @param {awesomepackage.IinvotePlayerInfo} message invotePlayerInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        invotePlayerInfo.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.nickname);
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.headUrl);
            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.sex);
            return writer;
        };

        /**
         * Encodes the specified invotePlayerInfo message, length delimited. Does not implicitly {@link awesomepackage.invotePlayerInfo.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.invotePlayerInfo
         * @static
         * @param {awesomepackage.IinvotePlayerInfo} message invotePlayerInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        invotePlayerInfo.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes an invotePlayerInfo message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.invotePlayerInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.invotePlayerInfo} invotePlayerInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        invotePlayerInfo.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.invotePlayerInfo();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.nickname = reader.string();
                    break;
                case 2:
                    message.headUrl = reader.string();
                    break;
                case 3:
                    message.sex = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("nickname"))
                throw $util.ProtocolError("missing required 'nickname'", { instance: message });
            if (!message.hasOwnProperty("headUrl"))
                throw $util.ProtocolError("missing required 'headUrl'", { instance: message });
            if (!message.hasOwnProperty("sex"))
                throw $util.ProtocolError("missing required 'sex'", { instance: message });
            return message;
        };

        /**
         * Decodes an invotePlayerInfo message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.invotePlayerInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.invotePlayerInfo} invotePlayerInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        invotePlayerInfo.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies an invotePlayerInfo message.
         * @function verify
         * @memberof awesomepackage.invotePlayerInfo
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        invotePlayerInfo.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isString(message.nickname))
                return "nickname: string expected";
            if (!$util.isString(message.headUrl))
                return "headUrl: string expected";
            if (typeof message.sex !== "boolean")
                return "sex: boolean expected";
            return null;
        };

        return invotePlayerInfo;
    })();

    awesomepackage.c2sRoomStart = (function() {

        /**
         * Properties of a c2sRoomStart.
         * @memberof awesomepackage
         * @interface Ic2sRoomStart
         * @property {number} invoteRoomId c2sRoomStart invoteRoomId
         */

        /**
         * Constructs a new c2sRoomStart.
         * @memberof awesomepackage
         * @classdesc Represents a c2sRoomStart.
         * @implements Ic2sRoomStart
         * @constructor
         * @param {awesomepackage.Ic2sRoomStart=} [properties] Properties to set
         */
        function c2sRoomStart(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sRoomStart invoteRoomId.
         * @member {number} invoteRoomId
         * @memberof awesomepackage.c2sRoomStart
         * @instance
         */
        c2sRoomStart.prototype.invoteRoomId = 0;

        /**
         * Creates a new c2sRoomStart instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sRoomStart
         * @static
         * @param {awesomepackage.Ic2sRoomStart=} [properties] Properties to set
         * @returns {awesomepackage.c2sRoomStart} c2sRoomStart instance
         */
        c2sRoomStart.create = function create(properties) {
            return new c2sRoomStart(properties);
        };

        /**
         * Encodes the specified c2sRoomStart message. Does not implicitly {@link awesomepackage.c2sRoomStart.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sRoomStart
         * @static
         * @param {awesomepackage.Ic2sRoomStart} message c2sRoomStart message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sRoomStart.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.invoteRoomId);
            return writer;
        };

        /**
         * Encodes the specified c2sRoomStart message, length delimited. Does not implicitly {@link awesomepackage.c2sRoomStart.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sRoomStart
         * @static
         * @param {awesomepackage.Ic2sRoomStart} message c2sRoomStart message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sRoomStart.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sRoomStart message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sRoomStart
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sRoomStart} c2sRoomStart
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sRoomStart.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sRoomStart();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.invoteRoomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("invoteRoomId"))
                throw $util.ProtocolError("missing required 'invoteRoomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sRoomStart message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sRoomStart
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sRoomStart} c2sRoomStart
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sRoomStart.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sRoomStart message.
         * @function verify
         * @memberof awesomepackage.c2sRoomStart
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sRoomStart.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.invoteRoomId))
                return "invoteRoomId: integer expected";
            return null;
        };

        return c2sRoomStart;
    })();

    awesomepackage.s2cRoomStart = (function() {

        /**
         * Properties of a s2cRoomStart.
         * @memberof awesomepackage
         * @interface Is2cRoomStart
         * @property {number} invoteRoomId s2cRoomStart invoteRoomId
         */

        /**
         * Constructs a new s2cRoomStart.
         * @memberof awesomepackage
         * @classdesc Represents a s2cRoomStart.
         * @implements Is2cRoomStart
         * @constructor
         * @param {awesomepackage.Is2cRoomStart=} [properties] Properties to set
         */
        function s2cRoomStart(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cRoomStart invoteRoomId.
         * @member {number} invoteRoomId
         * @memberof awesomepackage.s2cRoomStart
         * @instance
         */
        s2cRoomStart.prototype.invoteRoomId = 0;

        /**
         * Creates a new s2cRoomStart instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cRoomStart
         * @static
         * @param {awesomepackage.Is2cRoomStart=} [properties] Properties to set
         * @returns {awesomepackage.s2cRoomStart} s2cRoomStart instance
         */
        s2cRoomStart.create = function create(properties) {
            return new s2cRoomStart(properties);
        };

        /**
         * Encodes the specified s2cRoomStart message. Does not implicitly {@link awesomepackage.s2cRoomStart.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cRoomStart
         * @static
         * @param {awesomepackage.Is2cRoomStart} message s2cRoomStart message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cRoomStart.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.invoteRoomId);
            return writer;
        };

        /**
         * Encodes the specified s2cRoomStart message, length delimited. Does not implicitly {@link awesomepackage.s2cRoomStart.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cRoomStart
         * @static
         * @param {awesomepackage.Is2cRoomStart} message s2cRoomStart message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cRoomStart.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cRoomStart message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cRoomStart
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cRoomStart} s2cRoomStart
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cRoomStart.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cRoomStart();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.invoteRoomId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("invoteRoomId"))
                throw $util.ProtocolError("missing required 'invoteRoomId'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cRoomStart message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cRoomStart
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cRoomStart} s2cRoomStart
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cRoomStart.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cRoomStart message.
         * @function verify
         * @memberof awesomepackage.s2cRoomStart
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cRoomStart.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.invoteRoomId))
                return "invoteRoomId: integer expected";
            return null;
        };

        return s2cRoomStart;
    })();

    awesomepackage.c2sRoomExit = (function() {

        /**
         * Properties of a c2sRoomExit.
         * @memberof awesomepackage
         * @interface Ic2sRoomExit
         * @property {number} invoteRoomId c2sRoomExit invoteRoomId
         * @property {number} account c2sRoomExit account
         */

        /**
         * Constructs a new c2sRoomExit.
         * @memberof awesomepackage
         * @classdesc Represents a c2sRoomExit.
         * @implements Ic2sRoomExit
         * @constructor
         * @param {awesomepackage.Ic2sRoomExit=} [properties] Properties to set
         */
        function c2sRoomExit(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * c2sRoomExit invoteRoomId.
         * @member {number} invoteRoomId
         * @memberof awesomepackage.c2sRoomExit
         * @instance
         */
        c2sRoomExit.prototype.invoteRoomId = 0;

        /**
         * c2sRoomExit account.
         * @member {number} account
         * @memberof awesomepackage.c2sRoomExit
         * @instance
         */
        c2sRoomExit.prototype.account = 0;

        /**
         * Creates a new c2sRoomExit instance using the specified properties.
         * @function create
         * @memberof awesomepackage.c2sRoomExit
         * @static
         * @param {awesomepackage.Ic2sRoomExit=} [properties] Properties to set
         * @returns {awesomepackage.c2sRoomExit} c2sRoomExit instance
         */
        c2sRoomExit.create = function create(properties) {
            return new c2sRoomExit(properties);
        };

        /**
         * Encodes the specified c2sRoomExit message. Does not implicitly {@link awesomepackage.c2sRoomExit.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.c2sRoomExit
         * @static
         * @param {awesomepackage.Ic2sRoomExit} message c2sRoomExit message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sRoomExit.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.invoteRoomId);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.account);
            return writer;
        };

        /**
         * Encodes the specified c2sRoomExit message, length delimited. Does not implicitly {@link awesomepackage.c2sRoomExit.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.c2sRoomExit
         * @static
         * @param {awesomepackage.Ic2sRoomExit} message c2sRoomExit message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        c2sRoomExit.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a c2sRoomExit message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.c2sRoomExit
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.c2sRoomExit} c2sRoomExit
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sRoomExit.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.c2sRoomExit();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.invoteRoomId = reader.int32();
                    break;
                case 2:
                    message.account = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("invoteRoomId"))
                throw $util.ProtocolError("missing required 'invoteRoomId'", { instance: message });
            if (!message.hasOwnProperty("account"))
                throw $util.ProtocolError("missing required 'account'", { instance: message });
            return message;
        };

        /**
         * Decodes a c2sRoomExit message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.c2sRoomExit
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.c2sRoomExit} c2sRoomExit
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        c2sRoomExit.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a c2sRoomExit message.
         * @function verify
         * @memberof awesomepackage.c2sRoomExit
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        c2sRoomExit.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.invoteRoomId))
                return "invoteRoomId: integer expected";
            if (!$util.isInteger(message.account))
                return "account: integer expected";
            return null;
        };

        return c2sRoomExit;
    })();

    awesomepackage.s2cRoomExit = (function() {

        /**
         * Properties of a s2cRoomExit.
         * @memberof awesomepackage
         * @interface Is2cRoomExit
         * @property {number} invoteRoomId s2cRoomExit invoteRoomId
         * @property {string} result s2cRoomExit result
         */

        /**
         * Constructs a new s2cRoomExit.
         * @memberof awesomepackage
         * @classdesc Represents a s2cRoomExit.
         * @implements Is2cRoomExit
         * @constructor
         * @param {awesomepackage.Is2cRoomExit=} [properties] Properties to set
         */
        function s2cRoomExit(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * s2cRoomExit invoteRoomId.
         * @member {number} invoteRoomId
         * @memberof awesomepackage.s2cRoomExit
         * @instance
         */
        s2cRoomExit.prototype.invoteRoomId = 0;

        /**
         * s2cRoomExit result.
         * @member {string} result
         * @memberof awesomepackage.s2cRoomExit
         * @instance
         */
        s2cRoomExit.prototype.result = "";

        /**
         * Creates a new s2cRoomExit instance using the specified properties.
         * @function create
         * @memberof awesomepackage.s2cRoomExit
         * @static
         * @param {awesomepackage.Is2cRoomExit=} [properties] Properties to set
         * @returns {awesomepackage.s2cRoomExit} s2cRoomExit instance
         */
        s2cRoomExit.create = function create(properties) {
            return new s2cRoomExit(properties);
        };

        /**
         * Encodes the specified s2cRoomExit message. Does not implicitly {@link awesomepackage.s2cRoomExit.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.s2cRoomExit
         * @static
         * @param {awesomepackage.Is2cRoomExit} message s2cRoomExit message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cRoomExit.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.invoteRoomId);
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.result);
            return writer;
        };

        /**
         * Encodes the specified s2cRoomExit message, length delimited. Does not implicitly {@link awesomepackage.s2cRoomExit.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.s2cRoomExit
         * @static
         * @param {awesomepackage.Is2cRoomExit} message s2cRoomExit message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        s2cRoomExit.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a s2cRoomExit message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.s2cRoomExit
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.s2cRoomExit} s2cRoomExit
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cRoomExit.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.s2cRoomExit();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.invoteRoomId = reader.int32();
                    break;
                case 2:
                    message.result = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("invoteRoomId"))
                throw $util.ProtocolError("missing required 'invoteRoomId'", { instance: message });
            if (!message.hasOwnProperty("result"))
                throw $util.ProtocolError("missing required 'result'", { instance: message });
            return message;
        };

        /**
         * Decodes a s2cRoomExit message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.s2cRoomExit
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.s2cRoomExit} s2cRoomExit
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        s2cRoomExit.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a s2cRoomExit message.
         * @function verify
         * @memberof awesomepackage.s2cRoomExit
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        s2cRoomExit.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.invoteRoomId))
                return "invoteRoomId: integer expected";
            if (!$util.isString(message.result))
                return "result: string expected";
            return null;
        };

        return s2cRoomExit;
    })();

    awesomepackage.topUsrItem = (function() {

        /**
         * Properties of a topUsrItem.
         * @memberof awesomepackage
         * @interface ItopUsrItem
         * @property {string} name topUsrItem name
         * @property {number} tongueLength topUsrItem tongueLength
         */

        /**
         * Constructs a new topUsrItem.
         * @memberof awesomepackage
         * @classdesc Represents a topUsrItem.
         * @implements ItopUsrItem
         * @constructor
         * @param {awesomepackage.ItopUsrItem=} [properties] Properties to set
         */
        function topUsrItem(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * topUsrItem name.
         * @member {string} name
         * @memberof awesomepackage.topUsrItem
         * @instance
         */
        topUsrItem.prototype.name = "";

        /**
         * topUsrItem tongueLength.
         * @member {number} tongueLength
         * @memberof awesomepackage.topUsrItem
         * @instance
         */
        topUsrItem.prototype.tongueLength = 0;

        /**
         * Creates a new topUsrItem instance using the specified properties.
         * @function create
         * @memberof awesomepackage.topUsrItem
         * @static
         * @param {awesomepackage.ItopUsrItem=} [properties] Properties to set
         * @returns {awesomepackage.topUsrItem} topUsrItem instance
         */
        topUsrItem.create = function create(properties) {
            return new topUsrItem(properties);
        };

        /**
         * Encodes the specified topUsrItem message. Does not implicitly {@link awesomepackage.topUsrItem.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.topUsrItem
         * @static
         * @param {awesomepackage.ItopUsrItem} message topUsrItem message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        topUsrItem.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.tongueLength);
            return writer;
        };

        /**
         * Encodes the specified topUsrItem message, length delimited. Does not implicitly {@link awesomepackage.topUsrItem.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.topUsrItem
         * @static
         * @param {awesomepackage.ItopUsrItem} message topUsrItem message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        topUsrItem.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a topUsrItem message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.topUsrItem
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.topUsrItem} topUsrItem
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        topUsrItem.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.topUsrItem();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.tongueLength = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("name"))
                throw $util.ProtocolError("missing required 'name'", { instance: message });
            if (!message.hasOwnProperty("tongueLength"))
                throw $util.ProtocolError("missing required 'tongueLength'", { instance: message });
            return message;
        };

        /**
         * Decodes a topUsrItem message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.topUsrItem
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.topUsrItem} topUsrItem
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        topUsrItem.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a topUsrItem message.
         * @function verify
         * @memberof awesomepackage.topUsrItem
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        topUsrItem.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isString(message.name))
                return "name: string expected";
            if (!$util.isInteger(message.tongueLength))
                return "tongueLength: integer expected";
            return null;
        };

        return topUsrItem;
    })();

    awesomepackage.roomPlayerInfo = (function() {

        /**
         * Properties of a roomPlayerInfo.
         * @memberof awesomepackage
         * @interface IroomPlayerInfo
         * @property {string} name roomPlayerInfo name
         * @property {number} userId roomPlayerInfo userId
         * @property {number} x roomPlayerInfo x
         * @property {number} y roomPlayerInfo y
         * @property {number} frogType roomPlayerInfo frogType
         * @property {number} level roomPlayerInfo level
         * @property {number} lineLength roomPlayerInfo lineLength
         * @property {number} roomId roomPlayerInfo roomId
         * @property {boolean} ishadLine roomPlayerInfo ishadLine
         * @property {awesomepackage.ImPropStates} propStates roomPlayerInfo propStates
         * @property {awesomepackage.ImDeath} Death roomPlayerInfo Death
         * @property {awesomepackage.ImNewHandProtect} NewHandProtect roomPlayerInfo NewHandProtect
         * @property {awesomepackage.ImDressup} Dressup roomPlayerInfo Dressup
         */

        /**
         * Constructs a new roomPlayerInfo.
         * @memberof awesomepackage
         * @classdesc Represents a roomPlayerInfo.
         * @implements IroomPlayerInfo
         * @constructor
         * @param {awesomepackage.IroomPlayerInfo=} [properties] Properties to set
         */
        function roomPlayerInfo(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * roomPlayerInfo name.
         * @member {string} name
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.name = "";

        /**
         * roomPlayerInfo userId.
         * @member {number} userId
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.userId = 0;

        /**
         * roomPlayerInfo x.
         * @member {number} x
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.x = 0;

        /**
         * roomPlayerInfo y.
         * @member {number} y
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.y = 0;

        /**
         * roomPlayerInfo frogType.
         * @member {number} frogType
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.frogType = 0;

        /**
         * roomPlayerInfo level.
         * @member {number} level
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.level = 0;

        /**
         * roomPlayerInfo lineLength.
         * @member {number} lineLength
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.lineLength = 0;

        /**
         * roomPlayerInfo roomId.
         * @member {number} roomId
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.roomId = 0;

        /**
         * roomPlayerInfo ishadLine.
         * @member {boolean} ishadLine
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.ishadLine = false;

        /**
         * roomPlayerInfo propStates.
         * @member {awesomepackage.ImPropStates} propStates
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.propStates = null;

        /**
         * roomPlayerInfo Death.
         * @member {awesomepackage.ImDeath} Death
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.Death = null;

        /**
         * roomPlayerInfo NewHandProtect.
         * @member {awesomepackage.ImNewHandProtect} NewHandProtect
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.NewHandProtect = null;

        /**
         * roomPlayerInfo Dressup.
         * @member {awesomepackage.ImDressup} Dressup
         * @memberof awesomepackage.roomPlayerInfo
         * @instance
         */
        roomPlayerInfo.prototype.Dressup = null;

        /**
         * Creates a new roomPlayerInfo instance using the specified properties.
         * @function create
         * @memberof awesomepackage.roomPlayerInfo
         * @static
         * @param {awesomepackage.IroomPlayerInfo=} [properties] Properties to set
         * @returns {awesomepackage.roomPlayerInfo} roomPlayerInfo instance
         */
        roomPlayerInfo.create = function create(properties) {
            return new roomPlayerInfo(properties);
        };

        /**
         * Encodes the specified roomPlayerInfo message. Does not implicitly {@link awesomepackage.roomPlayerInfo.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.roomPlayerInfo
         * @static
         * @param {awesomepackage.IroomPlayerInfo} message roomPlayerInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        roomPlayerInfo.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.userId);
            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.x);
            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.y);
            writer.uint32(/* id 5, wireType 0 =*/40).int32(message.frogType);
            writer.uint32(/* id 6, wireType 0 =*/48).int32(message.level);
            writer.uint32(/* id 7, wireType 0 =*/56).int32(message.lineLength);
            writer.uint32(/* id 8, wireType 0 =*/64).int32(message.roomId);
            writer.uint32(/* id 9, wireType 0 =*/72).bool(message.ishadLine);
            $root.awesomepackage.mPropStates.encode(message.propStates, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
            $root.awesomepackage.mDeath.encode(message.Death, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
            $root.awesomepackage.mNewHandProtect.encode(message.NewHandProtect, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
            $root.awesomepackage.mDressup.encode(message.Dressup, writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
            return writer;
        };

        /**
         * Encodes the specified roomPlayerInfo message, length delimited. Does not implicitly {@link awesomepackage.roomPlayerInfo.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.roomPlayerInfo
         * @static
         * @param {awesomepackage.IroomPlayerInfo} message roomPlayerInfo message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        roomPlayerInfo.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a roomPlayerInfo message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.roomPlayerInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.roomPlayerInfo} roomPlayerInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        roomPlayerInfo.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.roomPlayerInfo();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.userId = reader.int32();
                    break;
                case 3:
                    message.x = reader.int32();
                    break;
                case 4:
                    message.y = reader.int32();
                    break;
                case 5:
                    message.frogType = reader.int32();
                    break;
                case 6:
                    message.level = reader.int32();
                    break;
                case 7:
                    message.lineLength = reader.int32();
                    break;
                case 8:
                    message.roomId = reader.int32();
                    break;
                case 9:
                    message.ishadLine = reader.bool();
                    break;
                case 10:
                    message.propStates = $root.awesomepackage.mPropStates.decode(reader, reader.uint32());
                    break;
                case 11:
                    message.Death = $root.awesomepackage.mDeath.decode(reader, reader.uint32());
                    break;
                case 12:
                    message.NewHandProtect = $root.awesomepackage.mNewHandProtect.decode(reader, reader.uint32());
                    break;
                case 13:
                    message.Dressup = $root.awesomepackage.mDressup.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("name"))
                throw $util.ProtocolError("missing required 'name'", { instance: message });
            if (!message.hasOwnProperty("userId"))
                throw $util.ProtocolError("missing required 'userId'", { instance: message });
            if (!message.hasOwnProperty("x"))
                throw $util.ProtocolError("missing required 'x'", { instance: message });
            if (!message.hasOwnProperty("y"))
                throw $util.ProtocolError("missing required 'y'", { instance: message });
            if (!message.hasOwnProperty("frogType"))
                throw $util.ProtocolError("missing required 'frogType'", { instance: message });
            if (!message.hasOwnProperty("level"))
                throw $util.ProtocolError("missing required 'level'", { instance: message });
            if (!message.hasOwnProperty("lineLength"))
                throw $util.ProtocolError("missing required 'lineLength'", { instance: message });
            if (!message.hasOwnProperty("roomId"))
                throw $util.ProtocolError("missing required 'roomId'", { instance: message });
            if (!message.hasOwnProperty("ishadLine"))
                throw $util.ProtocolError("missing required 'ishadLine'", { instance: message });
            if (!message.hasOwnProperty("propStates"))
                throw $util.ProtocolError("missing required 'propStates'", { instance: message });
            if (!message.hasOwnProperty("Death"))
                throw $util.ProtocolError("missing required 'Death'", { instance: message });
            if (!message.hasOwnProperty("NewHandProtect"))
                throw $util.ProtocolError("missing required 'NewHandProtect'", { instance: message });
            if (!message.hasOwnProperty("Dressup"))
                throw $util.ProtocolError("missing required 'Dressup'", { instance: message });
            return message;
        };

        /**
         * Decodes a roomPlayerInfo message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.roomPlayerInfo
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.roomPlayerInfo} roomPlayerInfo
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        roomPlayerInfo.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a roomPlayerInfo message.
         * @function verify
         * @memberof awesomepackage.roomPlayerInfo
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        roomPlayerInfo.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isString(message.name))
                return "name: string expected";
            if (!$util.isInteger(message.userId))
                return "userId: integer expected";
            if (!$util.isInteger(message.x))
                return "x: integer expected";
            if (!$util.isInteger(message.y))
                return "y: integer expected";
            if (!$util.isInteger(message.frogType))
                return "frogType: integer expected";
            if (!$util.isInteger(message.level))
                return "level: integer expected";
            if (!$util.isInteger(message.lineLength))
                return "lineLength: integer expected";
            if (!$util.isInteger(message.roomId))
                return "roomId: integer expected";
            if (typeof message.ishadLine !== "boolean")
                return "ishadLine: boolean expected";
            {
                var error = $root.awesomepackage.mPropStates.verify(message.propStates);
                if (error)
                    return "propStates." + error;
            }
            {
                var error = $root.awesomepackage.mDeath.verify(message.Death);
                if (error)
                    return "Death." + error;
            }
            {
                var error = $root.awesomepackage.mNewHandProtect.verify(message.NewHandProtect);
                if (error)
                    return "NewHandProtect." + error;
            }
            {
                var error = $root.awesomepackage.mDressup.verify(message.Dressup);
                if (error)
                    return "Dressup." + error;
            }
            return null;
        };

        return roomPlayerInfo;
    })();

    awesomepackage.mPropStates = (function() {

        /**
         * Properties of a mPropStates.
         * @memberof awesomepackage
         * @interface ImPropStates
         * @property {number} getPropType mPropStates getPropType
         * @property {number|Long} PropStartTime mPropStates PropStartTime
         */

        /**
         * Constructs a new mPropStates.
         * @memberof awesomepackage
         * @classdesc Represents a mPropStates.
         * @implements ImPropStates
         * @constructor
         * @param {awesomepackage.ImPropStates=} [properties] Properties to set
         */
        function mPropStates(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mPropStates getPropType.
         * @member {number} getPropType
         * @memberof awesomepackage.mPropStates
         * @instance
         */
        mPropStates.prototype.getPropType = 0;

        /**
         * mPropStates PropStartTime.
         * @member {number|Long} PropStartTime
         * @memberof awesomepackage.mPropStates
         * @instance
         */
        mPropStates.prototype.PropStartTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

        /**
         * Creates a new mPropStates instance using the specified properties.
         * @function create
         * @memberof awesomepackage.mPropStates
         * @static
         * @param {awesomepackage.ImPropStates=} [properties] Properties to set
         * @returns {awesomepackage.mPropStates} mPropStates instance
         */
        mPropStates.create = function create(properties) {
            return new mPropStates(properties);
        };

        /**
         * Encodes the specified mPropStates message. Does not implicitly {@link awesomepackage.mPropStates.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.mPropStates
         * @static
         * @param {awesomepackage.ImPropStates} message mPropStates message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mPropStates.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.getPropType);
            writer.uint32(/* id 2, wireType 0 =*/16).int64(message.PropStartTime);
            return writer;
        };

        /**
         * Encodes the specified mPropStates message, length delimited. Does not implicitly {@link awesomepackage.mPropStates.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.mPropStates
         * @static
         * @param {awesomepackage.ImPropStates} message mPropStates message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mPropStates.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mPropStates message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.mPropStates
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.mPropStates} mPropStates
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mPropStates.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.mPropStates();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.getPropType = reader.int32();
                    break;
                case 2:
                    message.PropStartTime = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("getPropType"))
                throw $util.ProtocolError("missing required 'getPropType'", { instance: message });
            if (!message.hasOwnProperty("PropStartTime"))
                throw $util.ProtocolError("missing required 'PropStartTime'", { instance: message });
            return message;
        };

        /**
         * Decodes a mPropStates message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.mPropStates
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.mPropStates} mPropStates
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mPropStates.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mPropStates message.
         * @function verify
         * @memberof awesomepackage.mPropStates
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mPropStates.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.getPropType))
                return "getPropType: integer expected";
            if (!$util.isInteger(message.PropStartTime) && !(message.PropStartTime && $util.isInteger(message.PropStartTime.low) && $util.isInteger(message.PropStartTime.high)))
                return "PropStartTime: integer|Long expected";
            return null;
        };

        return mPropStates;
    })();

    awesomepackage.mDeath = (function() {

        /**
         * Properties of a mDeath.
         * @memberof awesomepackage
         * @interface ImDeath
         * @property {boolean} isDeath mDeath isDeath
         * @property {number|Long} deadStartTime mDeath deadStartTime
         */

        /**
         * Constructs a new mDeath.
         * @memberof awesomepackage
         * @classdesc Represents a mDeath.
         * @implements ImDeath
         * @constructor
         * @param {awesomepackage.ImDeath=} [properties] Properties to set
         */
        function mDeath(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mDeath isDeath.
         * @member {boolean} isDeath
         * @memberof awesomepackage.mDeath
         * @instance
         */
        mDeath.prototype.isDeath = false;

        /**
         * mDeath deadStartTime.
         * @member {number|Long} deadStartTime
         * @memberof awesomepackage.mDeath
         * @instance
         */
        mDeath.prototype.deadStartTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

        /**
         * Creates a new mDeath instance using the specified properties.
         * @function create
         * @memberof awesomepackage.mDeath
         * @static
         * @param {awesomepackage.ImDeath=} [properties] Properties to set
         * @returns {awesomepackage.mDeath} mDeath instance
         */
        mDeath.create = function create(properties) {
            return new mDeath(properties);
        };

        /**
         * Encodes the specified mDeath message. Does not implicitly {@link awesomepackage.mDeath.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.mDeath
         * @static
         * @param {awesomepackage.ImDeath} message mDeath message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mDeath.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).bool(message.isDeath);
            writer.uint32(/* id 2, wireType 0 =*/16).int64(message.deadStartTime);
            return writer;
        };

        /**
         * Encodes the specified mDeath message, length delimited. Does not implicitly {@link awesomepackage.mDeath.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.mDeath
         * @static
         * @param {awesomepackage.ImDeath} message mDeath message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mDeath.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mDeath message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.mDeath
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.mDeath} mDeath
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mDeath.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.mDeath();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.isDeath = reader.bool();
                    break;
                case 2:
                    message.deadStartTime = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("isDeath"))
                throw $util.ProtocolError("missing required 'isDeath'", { instance: message });
            if (!message.hasOwnProperty("deadStartTime"))
                throw $util.ProtocolError("missing required 'deadStartTime'", { instance: message });
            return message;
        };

        /**
         * Decodes a mDeath message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.mDeath
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.mDeath} mDeath
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mDeath.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mDeath message.
         * @function verify
         * @memberof awesomepackage.mDeath
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mDeath.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (typeof message.isDeath !== "boolean")
                return "isDeath: boolean expected";
            if (!$util.isInteger(message.deadStartTime) && !(message.deadStartTime && $util.isInteger(message.deadStartTime.low) && $util.isInteger(message.deadStartTime.high)))
                return "deadStartTime: integer|Long expected";
            return null;
        };

        return mDeath;
    })();

    awesomepackage.mNewHandProtect = (function() {

        /**
         * Properties of a mNewHandProtect.
         * @memberof awesomepackage
         * @interface ImNewHandProtect
         * @property {boolean} isProtect mNewHandProtect isProtect
         * @property {number|Long} ProtectStartTime mNewHandProtect ProtectStartTime
         */

        /**
         * Constructs a new mNewHandProtect.
         * @memberof awesomepackage
         * @classdesc Represents a mNewHandProtect.
         * @implements ImNewHandProtect
         * @constructor
         * @param {awesomepackage.ImNewHandProtect=} [properties] Properties to set
         */
        function mNewHandProtect(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mNewHandProtect isProtect.
         * @member {boolean} isProtect
         * @memberof awesomepackage.mNewHandProtect
         * @instance
         */
        mNewHandProtect.prototype.isProtect = false;

        /**
         * mNewHandProtect ProtectStartTime.
         * @member {number|Long} ProtectStartTime
         * @memberof awesomepackage.mNewHandProtect
         * @instance
         */
        mNewHandProtect.prototype.ProtectStartTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

        /**
         * Creates a new mNewHandProtect instance using the specified properties.
         * @function create
         * @memberof awesomepackage.mNewHandProtect
         * @static
         * @param {awesomepackage.ImNewHandProtect=} [properties] Properties to set
         * @returns {awesomepackage.mNewHandProtect} mNewHandProtect instance
         */
        mNewHandProtect.create = function create(properties) {
            return new mNewHandProtect(properties);
        };

        /**
         * Encodes the specified mNewHandProtect message. Does not implicitly {@link awesomepackage.mNewHandProtect.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.mNewHandProtect
         * @static
         * @param {awesomepackage.ImNewHandProtect} message mNewHandProtect message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mNewHandProtect.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).bool(message.isProtect);
            writer.uint32(/* id 2, wireType 0 =*/16).int64(message.ProtectStartTime);
            return writer;
        };

        /**
         * Encodes the specified mNewHandProtect message, length delimited. Does not implicitly {@link awesomepackage.mNewHandProtect.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.mNewHandProtect
         * @static
         * @param {awesomepackage.ImNewHandProtect} message mNewHandProtect message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mNewHandProtect.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mNewHandProtect message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.mNewHandProtect
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.mNewHandProtect} mNewHandProtect
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mNewHandProtect.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.mNewHandProtect();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.isProtect = reader.bool();
                    break;
                case 2:
                    message.ProtectStartTime = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("isProtect"))
                throw $util.ProtocolError("missing required 'isProtect'", { instance: message });
            if (!message.hasOwnProperty("ProtectStartTime"))
                throw $util.ProtocolError("missing required 'ProtectStartTime'", { instance: message });
            return message;
        };

        /**
         * Decodes a mNewHandProtect message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.mNewHandProtect
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.mNewHandProtect} mNewHandProtect
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mNewHandProtect.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mNewHandProtect message.
         * @function verify
         * @memberof awesomepackage.mNewHandProtect
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mNewHandProtect.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (typeof message.isProtect !== "boolean")
                return "isProtect: boolean expected";
            if (!$util.isInteger(message.ProtectStartTime) && !(message.ProtectStartTime && $util.isInteger(message.ProtectStartTime.low) && $util.isInteger(message.ProtectStartTime.high)))
                return "ProtectStartTime: integer|Long expected";
            return null;
        };

        return mNewHandProtect;
    })();

    awesomepackage.mDressup = (function() {

        /**
         * Properties of a mDressup.
         * @memberof awesomepackage
         * @interface ImDressup
         * @property {number} decorateId mDressup decorateId
         * @property {number} trailingId mDressup trailingId
         */

        /**
         * Constructs a new mDressup.
         * @memberof awesomepackage
         * @classdesc Represents a mDressup.
         * @implements ImDressup
         * @constructor
         * @param {awesomepackage.ImDressup=} [properties] Properties to set
         */
        function mDressup(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mDressup decorateId.
         * @member {number} decorateId
         * @memberof awesomepackage.mDressup
         * @instance
         */
        mDressup.prototype.decorateId = 0;

        /**
         * mDressup trailingId.
         * @member {number} trailingId
         * @memberof awesomepackage.mDressup
         * @instance
         */
        mDressup.prototype.trailingId = 0;

        /**
         * Creates a new mDressup instance using the specified properties.
         * @function create
         * @memberof awesomepackage.mDressup
         * @static
         * @param {awesomepackage.ImDressup=} [properties] Properties to set
         * @returns {awesomepackage.mDressup} mDressup instance
         */
        mDressup.create = function create(properties) {
            return new mDressup(properties);
        };

        /**
         * Encodes the specified mDressup message. Does not implicitly {@link awesomepackage.mDressup.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.mDressup
         * @static
         * @param {awesomepackage.ImDressup} message mDressup message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mDressup.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.decorateId);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.trailingId);
            return writer;
        };

        /**
         * Encodes the specified mDressup message, length delimited. Does not implicitly {@link awesomepackage.mDressup.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.mDressup
         * @static
         * @param {awesomepackage.ImDressup} message mDressup message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mDressup.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mDressup message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.mDressup
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.mDressup} mDressup
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mDressup.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.mDressup();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.decorateId = reader.int32();
                    break;
                case 2:
                    message.trailingId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("decorateId"))
                throw $util.ProtocolError("missing required 'decorateId'", { instance: message });
            if (!message.hasOwnProperty("trailingId"))
                throw $util.ProtocolError("missing required 'trailingId'", { instance: message });
            return message;
        };

        /**
         * Decodes a mDressup message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.mDressup
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.mDressup} mDressup
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mDressup.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mDressup message.
         * @function verify
         * @memberof awesomepackage.mDressup
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mDressup.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.decorateId))
                return "decorateId: integer expected";
            if (!$util.isInteger(message.trailingId))
                return "trailingId: integer expected";
            return null;
        };

        return mDressup;
    })();

    awesomepackage.mPoint = (function() {

        /**
         * Properties of a mPoint.
         * @memberof awesomepackage
         * @interface ImPoint
         * @property {number} x mPoint x
         * @property {number} y mPoint y
         */

        /**
         * Constructs a new mPoint.
         * @memberof awesomepackage
         * @classdesc Represents a mPoint.
         * @implements ImPoint
         * @constructor
         * @param {awesomepackage.ImPoint=} [properties] Properties to set
         */
        function mPoint(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mPoint x.
         * @member {number} x
         * @memberof awesomepackage.mPoint
         * @instance
         */
        mPoint.prototype.x = 0;

        /**
         * mPoint y.
         * @member {number} y
         * @memberof awesomepackage.mPoint
         * @instance
         */
        mPoint.prototype.y = 0;

        /**
         * Creates a new mPoint instance using the specified properties.
         * @function create
         * @memberof awesomepackage.mPoint
         * @static
         * @param {awesomepackage.ImPoint=} [properties] Properties to set
         * @returns {awesomepackage.mPoint} mPoint instance
         */
        mPoint.create = function create(properties) {
            return new mPoint(properties);
        };

        /**
         * Encodes the specified mPoint message. Does not implicitly {@link awesomepackage.mPoint.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.mPoint
         * @static
         * @param {awesomepackage.ImPoint} message mPoint message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mPoint.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.x);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.y);
            return writer;
        };

        /**
         * Encodes the specified mPoint message, length delimited. Does not implicitly {@link awesomepackage.mPoint.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.mPoint
         * @static
         * @param {awesomepackage.ImPoint} message mPoint message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mPoint.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mPoint message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.mPoint
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.mPoint} mPoint
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mPoint.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.mPoint();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.x = reader.int32();
                    break;
                case 2:
                    message.y = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("x"))
                throw $util.ProtocolError("missing required 'x'", { instance: message });
            if (!message.hasOwnProperty("y"))
                throw $util.ProtocolError("missing required 'y'", { instance: message });
            return message;
        };

        /**
         * Decodes a mPoint message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.mPoint
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.mPoint} mPoint
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mPoint.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mPoint message.
         * @function verify
         * @memberof awesomepackage.mPoint
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mPoint.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.x))
                return "x: integer expected";
            if (!$util.isInteger(message.y))
                return "y: integer expected";
            return null;
        };

        return mPoint;
    })();

    awesomepackage.mLine = (function() {

        /**
         * Properties of a mLine.
         * @memberof awesomepackage
         * @interface ImLine
         * @property {number} uOI mLine uOI
         * @property {number} uTI mLine uTI
         * @property {awesomepackage.ImPoint} uO mLine uO
         * @property {awesomepackage.ImPoint} uT mLine uT
         * @property {number} t mLine t
         * @property {number} i mLine i
         */

        /**
         * Constructs a new mLine.
         * @memberof awesomepackage
         * @classdesc Represents a mLine.
         * @implements ImLine
         * @constructor
         * @param {awesomepackage.ImLine=} [properties] Properties to set
         */
        function mLine(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mLine uOI.
         * @member {number} uOI
         * @memberof awesomepackage.mLine
         * @instance
         */
        mLine.prototype.uOI = 0;

        /**
         * mLine uTI.
         * @member {number} uTI
         * @memberof awesomepackage.mLine
         * @instance
         */
        mLine.prototype.uTI = 0;

        /**
         * mLine uO.
         * @member {awesomepackage.ImPoint} uO
         * @memberof awesomepackage.mLine
         * @instance
         */
        mLine.prototype.uO = null;

        /**
         * mLine uT.
         * @member {awesomepackage.ImPoint} uT
         * @memberof awesomepackage.mLine
         * @instance
         */
        mLine.prototype.uT = null;

        /**
         * mLine t.
         * @member {number} t
         * @memberof awesomepackage.mLine
         * @instance
         */
        mLine.prototype.t = 0;

        /**
         * mLine i.
         * @member {number} i
         * @memberof awesomepackage.mLine
         * @instance
         */
        mLine.prototype.i = 0;

        /**
         * Creates a new mLine instance using the specified properties.
         * @function create
         * @memberof awesomepackage.mLine
         * @static
         * @param {awesomepackage.ImLine=} [properties] Properties to set
         * @returns {awesomepackage.mLine} mLine instance
         */
        mLine.create = function create(properties) {
            return new mLine(properties);
        };

        /**
         * Encodes the specified mLine message. Does not implicitly {@link awesomepackage.mLine.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.mLine
         * @static
         * @param {awesomepackage.ImLine} message mLine message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mLine.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.uOI);
            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.uTI);
            $root.awesomepackage.mPoint.encode(message.uO, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
            $root.awesomepackage.mPoint.encode(message.uT, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
            writer.uint32(/* id 5, wireType 0 =*/40).int32(message.t);
            writer.uint32(/* id 6, wireType 0 =*/48).int32(message.i);
            return writer;
        };

        /**
         * Encodes the specified mLine message, length delimited. Does not implicitly {@link awesomepackage.mLine.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.mLine
         * @static
         * @param {awesomepackage.ImLine} message mLine message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mLine.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mLine message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.mLine
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.mLine} mLine
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mLine.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.mLine();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.uOI = reader.int32();
                    break;
                case 2:
                    message.uTI = reader.int32();
                    break;
                case 3:
                    message.uO = $root.awesomepackage.mPoint.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.uT = $root.awesomepackage.mPoint.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.t = reader.int32();
                    break;
                case 6:
                    message.i = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("uOI"))
                throw $util.ProtocolError("missing required 'uOI'", { instance: message });
            if (!message.hasOwnProperty("uTI"))
                throw $util.ProtocolError("missing required 'uTI'", { instance: message });
            if (!message.hasOwnProperty("uO"))
                throw $util.ProtocolError("missing required 'uO'", { instance: message });
            if (!message.hasOwnProperty("uT"))
                throw $util.ProtocolError("missing required 'uT'", { instance: message });
            if (!message.hasOwnProperty("t"))
                throw $util.ProtocolError("missing required 't'", { instance: message });
            if (!message.hasOwnProperty("i"))
                throw $util.ProtocolError("missing required 'i'", { instance: message });
            return message;
        };

        /**
         * Decodes a mLine message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.mLine
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.mLine} mLine
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mLine.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mLine message.
         * @function verify
         * @memberof awesomepackage.mLine
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mLine.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.uOI))
                return "uOI: integer expected";
            if (!$util.isInteger(message.uTI))
                return "uTI: integer expected";
            {
                var error = $root.awesomepackage.mPoint.verify(message.uO);
                if (error)
                    return "uO." + error;
            }
            {
                var error = $root.awesomepackage.mPoint.verify(message.uT);
                if (error)
                    return "uT." + error;
            }
            if (!$util.isInteger(message.t))
                return "t: integer expected";
            if (!$util.isInteger(message.i))
                return "i: integer expected";
            return null;
        };

        return mLine;
    })();

    awesomepackage.mProp = (function() {

        /**
         * Properties of a mProp.
         * @memberof awesomepackage
         * @interface ImProp
         * @property {number} id mProp id
         * @property {awesomepackage.ImPoint} point mProp point
         * @property {number} type mProp type
         * @property {awesomepackage.ImPoint|null} [pointfrom] mProp pointfrom
         * @property {number|null} [value] mProp value
         */

        /**
         * Constructs a new mProp.
         * @memberof awesomepackage
         * @classdesc Represents a mProp.
         * @implements ImProp
         * @constructor
         * @param {awesomepackage.ImProp=} [properties] Properties to set
         */
        function mProp(properties) {
            if (properties)
                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                    if (properties[keys[i]] != null)
                        this[keys[i]] = properties[keys[i]];
        }

        /**
         * mProp id.
         * @member {number} id
         * @memberof awesomepackage.mProp
         * @instance
         */
        mProp.prototype.id = 0;

        /**
         * mProp point.
         * @member {awesomepackage.ImPoint} point
         * @memberof awesomepackage.mProp
         * @instance
         */
        mProp.prototype.point = null;

        /**
         * mProp type.
         * @member {number} type
         * @memberof awesomepackage.mProp
         * @instance
         */
        mProp.prototype.type = 0;

        /**
         * mProp pointfrom.
         * @member {awesomepackage.ImPoint|null|undefined} pointfrom
         * @memberof awesomepackage.mProp
         * @instance
         */
        mProp.prototype.pointfrom = null;

        /**
         * mProp value.
         * @member {number} value
         * @memberof awesomepackage.mProp
         * @instance
         */
        mProp.prototype.value = 0;

        /**
         * Creates a new mProp instance using the specified properties.
         * @function create
         * @memberof awesomepackage.mProp
         * @static
         * @param {awesomepackage.ImProp=} [properties] Properties to set
         * @returns {awesomepackage.mProp} mProp instance
         */
        mProp.create = function create(properties) {
            return new mProp(properties);
        };

        /**
         * Encodes the specified mProp message. Does not implicitly {@link awesomepackage.mProp.verify|verify} messages.
         * @function encode
         * @memberof awesomepackage.mProp
         * @static
         * @param {awesomepackage.ImProp} message mProp message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mProp.encode = function encode(message, writer) {
            if (!writer)
                writer = $Writer.create();
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.id);
            $root.awesomepackage.mPoint.encode(message.point, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.type);
            if (message.pointfrom != null && message.hasOwnProperty("pointfrom"))
                $root.awesomepackage.mPoint.encode(message.pointfrom, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
            if (message.value != null && message.hasOwnProperty("value"))
                writer.uint32(/* id 5, wireType 0 =*/40).int32(message.value);
            return writer;
        };

        /**
         * Encodes the specified mProp message, length delimited. Does not implicitly {@link awesomepackage.mProp.verify|verify} messages.
         * @function encodeDelimited
         * @memberof awesomepackage.mProp
         * @static
         * @param {awesomepackage.ImProp} message mProp message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        mProp.encodeDelimited = function encodeDelimited(message, writer) {
            return this.encode(message, writer).ldelim();
        };

        /**
         * Decodes a mProp message from the specified reader or buffer.
         * @function decode
         * @memberof awesomepackage.mProp
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @param {number} [length] Message length if known beforehand
         * @returns {awesomepackage.mProp} mProp
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mProp.decode = function decode(reader, length) {
            if (!(reader instanceof $Reader))
                reader = $Reader.create(reader);
            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.awesomepackage.mProp();
            while (reader.pos < end) {
                var tag = reader.uint32();
                switch (tag >>> 3) {
                case 1:
                    message.id = reader.int32();
                    break;
                case 2:
                    message.point = $root.awesomepackage.mPoint.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.type = reader.int32();
                    break;
                case 4:
                    message.pointfrom = $root.awesomepackage.mPoint.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.value = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
                }
            }
            if (!message.hasOwnProperty("id"))
                throw $util.ProtocolError("missing required 'id'", { instance: message });
            if (!message.hasOwnProperty("point"))
                throw $util.ProtocolError("missing required 'point'", { instance: message });
            if (!message.hasOwnProperty("type"))
                throw $util.ProtocolError("missing required 'type'", { instance: message });
            return message;
        };

        /**
         * Decodes a mProp message from the specified reader or buffer, length delimited.
         * @function decodeDelimited
         * @memberof awesomepackage.mProp
         * @static
         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
         * @returns {awesomepackage.mProp} mProp
         * @throws {Error} If the payload is not a reader or valid buffer
         * @throws {$protobuf.util.ProtocolError} If required fields are missing
         */
        mProp.decodeDelimited = function decodeDelimited(reader) {
            if (!(reader instanceof $Reader))
                reader = new $Reader(reader);
            return this.decode(reader, reader.uint32());
        };

        /**
         * Verifies a mProp message.
         * @function verify
         * @memberof awesomepackage.mProp
         * @static
         * @param {Object.<string,*>} message Plain object to verify
         * @returns {string|null} `null` if valid, otherwise the reason why it is not
         */
        mProp.verify = function verify(message) {
            if (typeof message !== "object" || message === null)
                return "object expected";
            if (!$util.isInteger(message.id))
                return "id: integer expected";
            {
                var error = $root.awesomepackage.mPoint.verify(message.point);
                if (error)
                    return "point." + error;
            }
            if (!$util.isInteger(message.type))
                return "type: integer expected";
            if (message.pointfrom != null && message.hasOwnProperty("pointfrom")) {
                var error = $root.awesomepackage.mPoint.verify(message.pointfrom);
                if (error)
                    return "pointfrom." + error;
            }
            if (message.value != null && message.hasOwnProperty("value"))
                if (!$util.isInteger(message.value))
                    return "value: integer expected";
            return null;
        };

        return mProp;
    })();

    return awesomepackage;
})();